CShellItem.cpp

Go to the documentation of this file.

/*
 * IShellItem implementation
 *
 * Copyright 2008 Vincent Povirk for CodeWeavers
 * Copyright 2009 Andrew Hill
 * Copyright 2013 Katayama Hirofumi MZ
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */
 
#include "precomp.h"
#include "prop.h"
 
WINE_DEFAULT_DEBUG_CHANNEL(shell);
 
CShellItem::CShellItem() :
    m_pidl(NULL)
{
}
 
CShellItem::~CShellItem()
{
    ILFree(m_pidl);
}
 
HRESULT CShellItem::get_parent_pidl(LPITEMIDLIST *parent_pidl)
{
    *parent_pidl = ILClone(m_pidl);
    if (*parent_pidl)
    {
        if (ILRemoveLastID(*parent_pidl))
            return S_OK;
        else
        {
            ILFree(*parent_pidl);
            *parent_pidl = NULL;
            return E_INVALIDARG;
        }
    }
    else
    {
        *parent_pidl = NULL;
        return E_OUTOFMEMORY;
    }
}
 
HRESULT CShellItem::get_parent_shellfolder(IShellFolder **ppsf)
{
    HRESULT hr;
    LPITEMIDLIST parent_pidl;
    CComPtr<IShellFolder>        desktop;
 
    hr = get_parent_pidl(&parent_pidl);
    if (SUCCEEDED(hr))
    {
        hr = SHGetDesktopFolder(&desktop);
        if (SUCCEEDED(hr))
            hr = desktop->BindToObject(parent_pidl, NULL, IID_PPV_ARG(IShellFolder, ppsf));
        ILFree(parent_pidl);
    }
 
    return hr;
}
 
HRESULT CShellItem::get_shellfolder(IBindCtx *pbc, REFIID riid, void **ppvOut)
{
    CComPtr<IShellFolder> psf;
    CComPtr<IShellFolder> psfDesktop;
    HRESULT ret;
 
    ret = SHGetDesktopFolder(&psfDesktop);
    if (FAILED_UNEXPECTEDLY(ret))
        return ret;
 
    if (_ILIsDesktop(m_pidl))
        psf = psfDesktop;
    else
    {
        ret = psfDesktop->BindToObject(m_pidl, pbc, IID_PPV_ARG(IShellFolder, &psf));
        if (FAILED_UNEXPECTEDLY(ret))
            return ret;
    }
 
    return psf->QueryInterface(riid, ppvOut);
}
 
HRESULT CShellItem::get_property_from_folder(REFPROPERTYKEY key, VARIANT *pvar)
{
    CComPtr<IShellFolder2> psf;
    PCUITEMID_CHILD pidl;
    HRESULT hr = SHBindToParent(m_pidl, IID_PPV_ARG(IShellFolder2, &psf), &pidl);
    if (SUCCEEDED(hr))
        return psf->GetDetailsEx(pidl, (const SHCOLUMNID*)&key, pvar);
    return hr;
}
 
HRESULT WINAPI CShellItem::BindToHandler(IBindCtx *pbc, REFGUID rbhid, REFIID riid, void **ppvOut)
{
    HRESULT ret;
    TRACE("(%p, %p,%s,%p,%p)\n", this, pbc, shdebugstr_guid(&rbhid), riid, ppvOut);
 
    *ppvOut = NULL;
    if (IsEqualGUID(rbhid, BHID_SFObject))
    {
        return get_shellfolder(pbc, riid, ppvOut);
    }
    else if (IsEqualGUID(rbhid, BHID_SFUIObject))
    {
        CComPtr<IShellFolder> psf_parent;
        if (_ILIsDesktop(m_pidl))
            ret = SHGetDesktopFolder(&psf_parent);
        else
            ret = get_parent_shellfolder(&psf_parent);
        if (FAILED_UNEXPECTEDLY(ret))
            return ret;
 
        LPCITEMIDLIST pidl = ILFindLastID(m_pidl);
        return psf_parent->GetUIObjectOf(NULL, 1, &pidl, riid, NULL, ppvOut);
    }
    else if (IsEqualGUID(rbhid, BHID_DataObject))
    {
        return BindToHandler(pbc, BHID_SFUIObject, IID_IDataObject, ppvOut);
    }
    else if (IsEqualGUID(rbhid, BHID_SFViewObject))
    {
        CComPtr<IShellFolder> psf;
        ret = get_shellfolder(NULL, IID_PPV_ARG(IShellFolder, &psf));
        if (FAILED_UNEXPECTEDLY(ret))
            return ret;
 
        return psf->CreateViewObject(NULL, riid, ppvOut);
    }
 
    FIXME("Unsupported BHID %s.\n", debugstr_guid(&rbhid));
 
    return MK_E_NOOBJECT;
}
 
HRESULT WINAPI CShellItem::GetParent(IShellItem **ppsi)
{
    HRESULT hr;
    LPITEMIDLIST parent_pidl;
 
    TRACE("(%p,%p)\n", this, ppsi);
 
    hr = get_parent_pidl(&parent_pidl);
    if (SUCCEEDED(hr))
    {
        hr = SHCreateShellItem(NULL, NULL, parent_pidl, ppsi);
        ILFree(parent_pidl);
    }
 
    return hr;
}
 
HRESULT WINAPI CShellItem::GetDisplayName(SIGDN sigdnName, LPWSTR *ppszName)
{
    return SHGetNameFromIDList(m_pidl, sigdnName, ppszName);
}
 
HRESULT WINAPI CShellItem::GetAttributes(SFGAOF sfgaoMask, SFGAOF *psfgaoAttribs)
{
    CComPtr<IShellFolder>        parent_folder;
    LPCITEMIDLIST child_pidl;
    HRESULT hr;
 
    TRACE("(%p,%x,%p)\n", this, sfgaoMask, psfgaoAttribs);
 
    if (_ILIsDesktop(m_pidl))
        hr = SHGetDesktopFolder(&parent_folder);
    else
        hr = get_parent_shellfolder(&parent_folder);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    child_pidl = ILFindLastID(m_pidl);
    *psfgaoAttribs = sfgaoMask;
    hr = parent_folder->GetAttributesOf(1, &child_pidl, psfgaoAttribs);
    *psfgaoAttribs &= sfgaoMask;
 
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    return (sfgaoMask == *psfgaoAttribs) ? S_OK : S_FALSE;
}
 
HRESULT WINAPI CShellItem::Compare(IShellItem *oth, SICHINTF hint, int *piOrder)
{
    HRESULT hr;
    CComPtr<IPersistIDList>      pIDList;
    CComPtr<IShellFolder>        psfDesktop;
    LPITEMIDLIST pidl;
 
    TRACE("(%p,%p,%x,%p)\n", this, oth, hint, piOrder);
 
    if (piOrder == NULL || oth == NULL)
        return E_POINTER;
 
    hr = oth->QueryInterface(IID_PPV_ARG(IPersistIDList, &pIDList));
    if (SUCCEEDED(hr))
    {
        hr = pIDList->GetIDList(&pidl);
        if (SUCCEEDED(hr))
        {
            hr = SHGetDesktopFolder(&psfDesktop);
            if (SUCCEEDED(hr))
            {
                hr = psfDesktop->CompareIDs(hint, m_pidl, pidl);
                *piOrder = (int)(short)SCODE_CODE(hr);
            }
            ILFree(pidl);
        }
    }
 
    if(FAILED(hr))
        return hr;
 
    if(*piOrder)
        return S_FALSE;
    else
        return S_OK;
}
 
HRESULT WINAPI CShellItem::GetPropertyStore(_In_ GETPROPERTYSTOREFLAGS flags,
                                            _In_ REFIID riid, _Out_ void **ppv)
{
    if (!ppv)
        return E_POINTER;
    UNIMPLEMENTED;
    *ppv = NULL;
    return E_NOTIMPL;
}
 
HRESULT WINAPI CShellItem::GetPropertyStoreWithCreateObject(_In_ GETPROPERTYSTOREFLAGS flags,
                                                            _In_ IUnknown *punkCreateObject,
                                                            _In_ REFIID riid, _Out_ void **ppv)
{
    if (!ppv)
        return E_POINTER;
    if (!punkCreateObject)
        return E_INVALIDARG;
    UNIMPLEMENTED;
    *ppv = NULL;
    return E_NOTIMPL;
}
 
HRESULT WINAPI CShellItem::GetPropertyStoreForKeys(const PROPERTYKEY *rgKeys, _In_ UINT cKeys,
                                                   _In_ GETPROPERTYSTOREFLAGS flags,
                                                   _In_ REFIID riid, _Out_ void **ppv)
{
    if (!ppv)
        return E_POINTER;
    UNIMPLEMENTED;
    *ppv = NULL;
    return E_NOTIMPL;
}
 
HRESULT WINAPI CShellItem::GetPropertyDescriptionList(_In_ REFPROPERTYKEY keyType, _In_ REFIID riid,
                                                      _Out_ void **ppv)
{
    if (!ppv)
        return E_POINTER;
    UNIMPLEMENTED; // TODO: propsys::PSCreatePropertyDescriptionList? IShellItemArray::GetPropertyDescriptionList?
    *ppv = NULL;
    return E_NOTIMPL;
}
 
HRESULT WINAPI CShellItem::Update(_In_ IBindCtx *pbc)
{
    UNIMPLEMENTED;
    return E_NOTIMPL;
}
 
HRESULT WINAPI CShellItem::GetProperty(_In_ REFPROPERTYKEY key, _Out_ PROPVARIANT *ppropvar)
{
    VARIANT v;
    HRESULT hr = get_property_from_folder(key, &v); // TODO: BHID_PropertyStore?
    if (FAILED(hr))
    {
        if (HRESULT_FACILITY(hr) == FACILITY_WIN32 && hr != E_INVALIDARG)
            return hr;
        return HResultFromWin32(ERROR_NOT_FOUND);
    }
    return SHELL_VariantToPropVariant(&v, ppropvar);
}
 
HRESULT CShellItem::get_converted_property(REFPROPERTYKEY key, PROPVARIANT *ppropvar, VARTYPE vt)
{
    PROPVARIANT pv;
    pv.vt = VT_EMPTY;
    HRESULT hr = GetProperty(key, &pv);
    if (FAILED(hr))
        return hr;
    hr = SHELL_PropVariantChangeType(ppropvar, pv, vt);
    PropVariantClear(&pv);
    return hr;
}
 
HRESULT WINAPI CShellItem::GetCLSID(_In_ REFPROPERTYKEY key, _Out_ CLSID *pclsid)
{
    if (!pclsid)
        return E_INVALIDARG;
 
    PROPVARIANT pv;
    pv.vt = VT_EMPTY;
    HRESULT hr = get_converted_property(key, &pv, VT_CLSID);
    *pclsid = SUCCEEDED(hr) ? *pv.puuid : GUID_NULL;
    PropVariantClear(&pv);
    return hr;
}
 
HRESULT WINAPI CShellItem::GetFileTime(_In_ REFPROPERTYKEY key, _Out_ FILETIME *pft)
{
    if (!pft)
        return E_INVALIDARG;
 
    const FILETIME failval = {};
    PROPVARIANT pv;
    pv.vt = VT_EMPTY;
    HRESULT hr = get_converted_property(key, &pv, VT_FILETIME);
    *pft = SUCCEEDED(hr) ? pv.filetime : failval;
    return hr;
}
 
HRESULT WINAPI CShellItem::GetString(_In_ REFPROPERTYKEY key, _Out_ LPWSTR *ppsz)
{
    if (!ppsz)
        return E_INVALIDARG;
 
    PROPVARIANT pv;
    pv.vt = VT_EMPTY;
    HRESULT hr = get_converted_property(key, &pv, VT_LPWSTR);
    *ppsz = SUCCEEDED(hr) ? pv.pwszVal : NULL; // Transferring ownership, don't call PropVariantClear
    return hr;
}
 
HRESULT WINAPI CShellItem::GetInt32(_In_ REFPROPERTYKEY key, _Out_ int *pi)
{
    if (!pi)
        return E_INVALIDARG;
 
    PROPVARIANT pv;
    pv.vt = VT_EMPTY;
    HRESULT hr = get_converted_property(key, &pv, VT_I4);
    *pi = SUCCEEDED(hr) ? pv.lVal : 0;
    return hr;
}
 
HRESULT WINAPI CShellItem::GetUInt32(_In_ REFPROPERTYKEY key, _Out_ ULONG *pui)
{
    if (!pui)
        return E_INVALIDARG;
 
    PROPVARIANT pv;
    pv.vt = VT_EMPTY;
    HRESULT hr = get_converted_property(key, &pv, VT_UI4);
    *pui = SUCCEEDED(hr) ? pv.ulVal : 0;
    return hr;
}
 
HRESULT WINAPI CShellItem::GetUInt64(_In_ REFPROPERTYKEY key, _Out_ ULONGLONG *pull)
{
    if (!pull)
        return E_INVALIDARG;
 
    PROPVARIANT pv;
    pv.vt = VT_EMPTY;
    HRESULT hr = get_converted_property(key, &pv, VT_UI8);
    *pull = SUCCEEDED(hr) ? pv.uhVal.QuadPart : 0;
    return hr;
}
 
HRESULT WINAPI CShellItem::GetBool(_In_ REFPROPERTYKEY key, _Out_ BOOL *pf)
{
    if (!pf)
        return E_INVALIDARG;
 
    PROPVARIANT pv;
    pv.vt = VT_EMPTY;
    HRESULT hr = get_converted_property(key, &pv, VT_BOOL);
    *pf = SUCCEEDED(hr) && V_BOOL((VARIANT*)&pv) != VARIANT_FALSE;
    return hr;
}
 
HRESULT WINAPI CShellItem::GetClassID(CLSID *pClassID)
{
    TRACE("(%p,%p)\n", this, pClassID);
 
    *pClassID = CLSID_ShellItem;
    return S_OK;
}
 
HRESULT WINAPI CShellItem::SetIDList(PCIDLIST_ABSOLUTE pidlx)
{
    LPITEMIDLIST new_pidl;
 
    TRACE("(%p,%p)\n", this, pidlx);
 
    new_pidl = ILClone(pidlx);
    if (new_pidl)
    {
        ILFree(m_pidl);
        m_pidl = new_pidl;
        return S_OK;
    }
    else
        return E_OUTOFMEMORY;
}
 
HRESULT WINAPI CShellItem::GetIDList(PIDLIST_ABSOLUTE *ppidl)
{
    TRACE("(%p,%p)\n", this, ppidl);
 
    *ppidl = ILClone(m_pidl);
    if (*ppidl)
        return S_OK;
    else
        return E_OUTOFMEMORY;
}
 
HRESULT WINAPI SHCreateShellItem(PCIDLIST_ABSOLUTE pidlParent,
    IShellFolder *psfParent, PCUITEMID_CHILD pidl, IShellItem **ppsi)
{
    HRESULT hr;
    CComPtr<IShellItem> newShellItem;
    LPITEMIDLIST new_pidl;
    CComPtr<IPersistIDList>            newPersistIDList;
 
    TRACE("(%p,%p,%p,%p)\n", pidlParent, psfParent, pidl, ppsi);
 
    *ppsi = NULL;
 
    if (!pidl)
        return E_INVALIDARG;
 
    if (pidlParent || psfParent)
    {
        LPITEMIDLIST temp_parent = NULL;
        if (!pidlParent)
        {
            CComPtr<IPersistFolder2>    ppf2Parent;
 
            if (FAILED(psfParent->QueryInterface(IID_PPV_ARG(IPersistFolder2, &ppf2Parent))))
            {
                FIXME("couldn't get IPersistFolder2 interface of parent\n");
                return E_NOINTERFACE;
            }
 
            if (FAILED(ppf2Parent->GetCurFolder(&temp_parent)))
            {
                FIXME("couldn't get parent PIDL\n");
                return E_NOINTERFACE;
            }
 
            pidlParent = temp_parent;
        }
 
        new_pidl = ILCombine(pidlParent, pidl);
        ILFree(temp_parent);
 
        if (!new_pidl)
            return E_OUTOFMEMORY;
    }
    else
    {
        new_pidl = ILClone(pidl);
        if (!new_pidl)
            return E_OUTOFMEMORY;
    }
 
    hr = CShellItem::_CreatorClass::CreateInstance(NULL, IID_PPV_ARG(IShellItem, &newShellItem));
    if (FAILED(hr))
    {
        ILFree(new_pidl);
        return hr;
    }
    hr = newShellItem->QueryInterface(IID_PPV_ARG(IPersistIDList, &newPersistIDList));
    if (FAILED(hr))
    {
        ILFree(new_pidl);
        return hr;
    }
    hr = newPersistIDList->SetIDList(new_pidl);
    if (FAILED(hr))
    {
        ILFree(new_pidl);
        return hr;
    }
    ILFree(new_pidl);
 
    *ppsi = newShellItem.Detach();
 
    return hr;
}
 
/***********************************************************************
 *   SHCreateItemFromIDList [SHELL32.@]
 */
EXTERN_C HRESULT WINAPI
SHCreateItemFromIDList(_In_ PCIDLIST_ABSOLUTE pidl, _In_ REFIID riid, _Out_ void **ppv)
{
    CComPtr<IShellItem> item;
    HRESULT hr;
 
    TRACE("(%p,%s,%p)\n", pidl, debugstr_guid(&riid), ppv);
 
    if (!ppv)
        return E_POINTER;
    *ppv = NULL;
 
    if (!pidl)
        return E_INVALIDARG;
 
    hr = SHCreateShellItem(NULL, NULL, pidl, &item);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    return item->QueryInterface(riid, ppv);
}
 
/***********************************************************************
 *   SHCreateItemFromParsingName [SHELL32.@]
 */
EXTERN_C HRESULT WINAPI
SHCreateItemFromParsingName(
    _In_ PCWSTR pszPath,
    _In_opt_ IBindCtx *pbc,
    _In_ REFIID riid,
    _Out_ void **ppv)
{
    CComHeapPtr<ITEMIDLIST> pidl;
    HRESULT hr;
 
    TRACE("(%s,%p,%s,%p)\n", debugstr_w(pszPath), pbc, debugstr_guid(&riid), ppv);
 
    if (!ppv)
        return E_POINTER;
    *ppv = NULL;
 
    hr = SHParseDisplayName(pszPath, pbc, &pidl, 0, NULL);
    if (SUCCEEDED(hr))
        hr = SHCreateItemFromIDList(pidl, riid, ppv);
 
    return hr;
}
 
/***********************************************************************
 *   SHGetItemFromDataObject [SHELL32.@]
 */
EXTERN_C HRESULT WINAPI
SHGetItemFromDataObject(
    _In_ IDataObject *pdtobj,
    _In_ DATAOBJ_GET_ITEM_FLAGS dwFlags,
    _In_ REFIID riid,
    _Out_ void **ppv)
{
    FORMATETC fmt;
    STGMEDIUM medium = { 0 };
    HRESULT hr;
 
    TRACE("(%p,%x,%s,%p)\n", pdtobj, dwFlags, debugstr_guid(&riid), ppv);
 
    if (!pdtobj)
        return E_INVALIDARG;
 
    fmt.cfFormat = (CLIPFORMAT)RegisterClipboardFormatW(CFSTR_SHELLIDLISTW);
    fmt.ptd = NULL;
    fmt.dwAspect = DVASPECT_CONTENT;
    fmt.lindex = -1;
    fmt.tymed = TYMED_HGLOBAL;
 
    hr = pdtobj->GetData(&fmt, &medium);
    if (SUCCEEDED(hr))
    {
        LPIDA pida = (LPIDA)GlobalLock(medium.hGlobal);
        if (pida && pida->cidl >= 1 &&
            ((pida->cidl > 1 && !(dwFlags & DOGIF_ONLY_IF_ONE)) || pida->cidl == 1))
        {
            LPITEMIDLIST pidl = ILCombine(HIDA_GetPIDLFolder(pida),
                                          HIDA_GetPIDLItem(pida, 0));
            if (pidl)
            {
                hr = SHCreateItemFromIDList(pidl, riid, ppv);
                ILFree(pidl);
            }
            else
            {
                hr = E_OUTOFMEMORY;
            }
        }
        else
        {
            TRACE("Failed to create item, cidl=%u, dwFlags=%#x\n", pida ? pida->cidl : 0, dwFlags);
            hr = E_FAIL;
        }
 
        if (medium.hGlobal)
        {
            GlobalUnlock(medium.hGlobal);
            ReleaseStgMedium(&medium);
        }
    }
 
    if (FAILED(hr) && !(dwFlags & DOGIF_NO_HDROP))
    {
        TRACE("Attempting to fall back on CF_HDROP.\n");
 
        fmt.cfFormat = CF_HDROP;
        fmt.ptd = NULL;
        fmt.dwAspect = DVASPECT_CONTENT;
        fmt.lindex = -1;
        fmt.tymed = TYMED_HGLOBAL;
        ZeroMemory(&medium, sizeof(medium));
 
        hr = pdtobj->GetData(&fmt, &medium);
        if (SUCCEEDED(hr))
        {
            DROPFILES *df = (DROPFILES *)GlobalLock(medium.hGlobal);
            hr = E_FAIL;
            if (df)
            {
                LPBYTE files = (LPBYTE)df + df->pFiles;
                if (!df->fWide)
                {
                    PCSTR first = (PCSTR)files;
                    BOOL multi = *(first + lstrlenA(first) + 1) != 0;
                    if (!(multi && (dwFlags & DOGIF_ONLY_IF_ONE)))
                    {
                        WCHAR filename[MAX_PATH];
                        MultiByteToWideChar(CP_ACP, 0, first, -1, filename, _countof(filename));
                        hr = SHCreateItemFromParsingName(filename, NULL, riid, ppv);
                    }
                }
                else
                {
                    PCWSTR first = (PCWSTR)files;
                    BOOL multi = *(first + lstrlenW(first) + 1) != 0;
                    if (!(multi && (dwFlags & DOGIF_ONLY_IF_ONE)))
                        hr = SHCreateItemFromParsingName(first, NULL, riid, ppv);
                }
                GlobalUnlock(medium.hGlobal);
            }
            ReleaseStgMedium(&medium);
        }
    }
 
    if (FAILED(hr) && !(dwFlags & DOGIF_NO_URL))
        FIXME("Failed to create item, should try CF_URL.\n");
 
    return hr;
}
 
#if DLL_EXPORT_VERSION >= _WIN32_WINNT_VISTA
 
/***********************************************************************
 *   SHCreateItemFromRelativeName [SHELL32.@]
 */
EXTERN_C HRESULT WINAPI
SHCreateItemFromRelativeName(
    _In_ IShellItem *parent,
    _In_ PCWSTR pszName,
    _In_opt_ IBindCtx *pbc,
    _In_ REFIID riid,
    _Out_ void **ppv)
{
    CComPtr<IShellFolder> desktop;
    CComPtr<IShellFolder> folder;
    CComHeapPtr<ITEMIDLIST> pidlFolder;
    CComHeapPtr<ITEMIDLIST> pidlChild;
    HRESULT hr;
 
    TRACE("(%p,%s,%p,%s,%p)\n", parent, debugstr_w(pszName), pbc, debugstr_guid(&riid), ppv);
 
    if (!ppv)
        return E_POINTER;
    *ppv = NULL;
 
    if (!pszName)
        return E_INVALIDARG;
 
    hr = SHGetIDListFromObject(parent, &pidlFolder);
    if (hr != S_OK)
        return hr;
 
    hr = SHGetDesktopFolder(&desktop);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    if (!_ILIsDesktop(pidlFolder))
    {
        hr = desktop->BindToObject(pidlFolder, NULL, IID_PPV_ARG(IShellFolder, &folder));
        if (FAILED_UNEXPECTEDLY(hr))
            return hr;
    }
 
    {
        IShellFolder *psfBind = folder.p ? folder.p : desktop.p;
        hr = psfBind->ParseDisplayName(NULL, pbc, const_cast<LPWSTR>(pszName), NULL, &pidlChild, NULL);
    }
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    return SHCreateItemFromIDList(pidlChild, riid, ppv);
}
 
/***********************************************************************
 *   SHCreateItemInKnownFolder [SHELL32.@]
 */
EXTERN_C HRESULT WINAPI SHGetKnownFolderIDList(
    REFKNOWNFOLDERID rfid,
    DWORD flags,
    HANDLE token,
    PIDLIST_ABSOLUTE *pidl);
 
EXTERN_C HRESULT WINAPI
SHCreateItemInKnownFolder(
    _In_ REFKNOWNFOLDERID kfid,
    _In_ DWORD dwFlags,
    _In_opt_ PCWSTR pszFileName,
    _In_ REFIID riid,
    _Out_ void **ppv)
{
    CComPtr<IShellItem> parent;
    CComHeapPtr<ITEMIDLIST> pidl;
    HRESULT hr;
 
    TRACE("(%s,%lx,%s,%s,%p)\n", debugstr_guid(&kfid), dwFlags, debugstr_w(pszFileName),
          debugstr_guid(&riid), ppv);
 
    if (!ppv)
        return E_POINTER;
    *ppv = NULL;
 
    hr = SHGetKnownFolderIDList(kfid, dwFlags, NULL, &pidl);
    if (hr != S_OK)
        return hr;
 
    hr = SHCreateItemFromIDList(pidl, IID_PPV_ARG(IShellItem, &parent));
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    if (pszFileName)
        hr = SHCreateItemFromRelativeName(parent, pszFileName, NULL, riid, ppv);
    else
        hr = parent->QueryInterface(riid, ppv);
 
    return hr;
}
 
/***********************************************************************
 *   SHGetItemFromObject [SHELL32.@]
 */
EXTERN_C HRESULT WINAPI
SHGetItemFromObject(_In_ IUnknown *punk, _In_ REFIID riid, _Out_ void **ppv)
{
    CComHeapPtr<ITEMIDLIST> pidl;
    HRESULT hr;
 
    TRACE("(%p,%s,%p)\n", punk, debugstr_guid(&riid), ppv);
 
    hr = SHGetIDListFromObject(punk, &pidl);
    if (SUCCEEDED(hr))
        hr = SHCreateItemFromIDList(pidl, riid, ppv);
    return hr;
}
 
/***********************************************************************
 *   SHGetPropertyStoreFromParsingName [SHELL32.@]
 */
EXTERN_C HRESULT WINAPI
SHGetPropertyStoreFromParsingName(
    _In_ PCWSTR pszPath,
    _In_opt_ IBindCtx *pbc,
    _In_ GETPROPERTYSTOREFLAGS flags,
    _In_ REFIID riid,
    _Out_ void **ppv)
{
    CComPtr<IShellItem2> item;
    HRESULT hr;
 
    TRACE("(%s,%p,%#x,%s,%p)\n", debugstr_w(pszPath), pbc, flags, debugstr_guid(&riid), ppv);
 
    if (!ppv)
        return E_POINTER;
    *ppv = NULL;
 
    hr = SHCreateItemFromParsingName(pszPath, pbc, IID_PPV_ARG(IShellItem2, &item));
    if (SUCCEEDED(hr))
        hr = item->GetPropertyStore(flags, riid, ppv);
 
    return hr;
}
 
#endif /* DLL_EXPORT_VERSION >= _WIN32_WINNT_VISTA */