| /* |
| * IShellItem and IShellItemArray implementations |
| * |
| * Copyright 2008 Vincent Povirk for CodeWeavers |
| * |
| * 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 "config.h" |
| #include "wine/port.h" |
| |
| #include <stdio.h> |
| #include <stdarg.h> |
| |
| #define COBJMACROS |
| #define NONAMELESSUNION |
| #define NONAMELESSSTRUCT |
| |
| #include "windef.h" |
| #include "winbase.h" |
| #include "wine/debug.h" |
| |
| #include "pidl.h" |
| #include "shell32_main.h" |
| #include "debughlp.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(shell); |
| |
| typedef struct _ShellItem { |
| IShellItem2 IShellItem2_iface; |
| LONG ref; |
| LPITEMIDLIST pidl; |
| IPersistIDList IPersistIDList_iface; |
| } ShellItem; |
| |
| static inline ShellItem *impl_from_IShellItem2(IShellItem2 *iface) |
| { |
| return CONTAINING_RECORD(iface, ShellItem, IShellItem2_iface); |
| } |
| |
| |
| static inline ShellItem *impl_from_IPersistIDList( IPersistIDList *iface ) |
| { |
| return CONTAINING_RECORD(iface, ShellItem, IPersistIDList_iface); |
| } |
| |
| |
| static HRESULT WINAPI ShellItem_QueryInterface(IShellItem2 *iface, REFIID riid, |
| void **ppv) |
| { |
| ShellItem *This = impl_from_IShellItem2(iface); |
| |
| TRACE("(%p,%p,%p)\n", iface, riid, ppv); |
| |
| if (!ppv) return E_INVALIDARG; |
| |
| if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IShellItem, riid) || |
| IsEqualIID(&IID_IShellItem2, riid)) |
| { |
| *ppv = This; |
| } |
| else if (IsEqualIID(&IID_IPersist, riid) || IsEqualIID(&IID_IPersistIDList, riid)) |
| { |
| *ppv = &This->IPersistIDList_iface; |
| } |
| else { |
| FIXME("not implemented for %s\n", shdebugstr_guid(riid)); |
| *ppv = NULL; |
| return E_NOINTERFACE; |
| } |
| |
| IUnknown_AddRef((IUnknown*)*ppv); |
| return S_OK; |
| } |
| |
| static ULONG WINAPI ShellItem_AddRef(IShellItem2 *iface) |
| { |
| ShellItem *This = impl_from_IShellItem2(iface); |
| ULONG ref = InterlockedIncrement(&This->ref); |
| |
| TRACE("(%p), new refcount=%i\n", iface, ref); |
| |
| return ref; |
| } |
| |
| static ULONG WINAPI ShellItem_Release(IShellItem2 *iface) |
| { |
| ShellItem *This = impl_from_IShellItem2(iface); |
| ULONG ref = InterlockedDecrement(&This->ref); |
| |
| TRACE("(%p), new refcount=%i\n", iface, ref); |
| |
| if (ref == 0) |
| { |
| ILFree(This->pidl); |
| HeapFree(GetProcessHeap(), 0, This); |
| } |
| |
| return ref; |
| } |
| |
| static HRESULT ShellItem_get_parent_pidl(ShellItem *This, LPITEMIDLIST *parent_pidl) |
| { |
| *parent_pidl = ILClone(This->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; |
| } |
| } |
| |
| static HRESULT ShellItem_get_parent_shellfolder(ShellItem *This, IShellFolder **ppsf) |
| { |
| LPITEMIDLIST parent_pidl; |
| IShellFolder *desktop; |
| HRESULT ret; |
| |
| ret = ShellItem_get_parent_pidl(This, &parent_pidl); |
| if (SUCCEEDED(ret)) |
| { |
| ret = SHGetDesktopFolder(&desktop); |
| if (SUCCEEDED(ret)) |
| { |
| ret = IShellFolder_BindToObject(desktop, parent_pidl, NULL, &IID_IShellFolder, (void**)ppsf); |
| IShellFolder_Release(desktop); |
| } |
| ILFree(parent_pidl); |
| } |
| |
| return ret; |
| } |
| |
| static HRESULT ShellItem_get_shellfolder(ShellItem *This, IBindCtx *pbc, IShellFolder **ppsf) |
| { |
| IShellFolder *desktop; |
| HRESULT ret; |
| |
| ret = SHGetDesktopFolder(&desktop); |
| if (SUCCEEDED(ret)) |
| { |
| if (_ILIsDesktop(This->pidl)) |
| { |
| *ppsf = desktop; |
| IShellFolder_AddRef(*ppsf); |
| } |
| else |
| { |
| ret = IShellFolder_BindToObject(desktop, This->pidl, pbc, &IID_IShellFolder, (void**)ppsf); |
| } |
| |
| IShellFolder_Release(desktop); |
| } |
| |
| return ret; |
| } |
| |
| static HRESULT WINAPI ShellItem_BindToHandler(IShellItem2 *iface, IBindCtx *pbc, |
| REFGUID rbhid, REFIID riid, void **ppvOut) |
| { |
| ShellItem *This = impl_from_IShellItem2(iface); |
| HRESULT ret; |
| TRACE("(%p,%p,%s,%p,%p)\n", iface, pbc, shdebugstr_guid(rbhid), riid, ppvOut); |
| |
| *ppvOut = NULL; |
| if (IsEqualGUID(rbhid, &BHID_SFObject)) |
| { |
| IShellFolder *psf; |
| ret = ShellItem_get_shellfolder(This, pbc, &psf); |
| if (SUCCEEDED(ret)) |
| { |
| ret = IShellFolder_QueryInterface(psf, riid, ppvOut); |
| IShellFolder_Release(psf); |
| } |
| return ret; |
| } |
| else if (IsEqualGUID(rbhid, &BHID_SFUIObject)) |
| { |
| IShellFolder *psf_parent; |
| if (_ILIsDesktop(This->pidl)) |
| ret = SHGetDesktopFolder(&psf_parent); |
| else |
| ret = ShellItem_get_parent_shellfolder(This, &psf_parent); |
| |
| if (SUCCEEDED(ret)) |
| { |
| LPCITEMIDLIST pidl = ILFindLastID(This->pidl); |
| ret = IShellFolder_GetUIObjectOf(psf_parent, NULL, 1, &pidl, riid, NULL, ppvOut); |
| IShellFolder_Release(psf_parent); |
| } |
| return ret; |
| } |
| else if (IsEqualGUID(rbhid, &BHID_DataObject)) |
| { |
| return ShellItem_BindToHandler(&This->IShellItem2_iface, pbc, &BHID_SFUIObject, |
| &IID_IDataObject, ppvOut); |
| } |
| |
| FIXME("Unsupported BHID %s.\n", debugstr_guid(rbhid)); |
| |
| return MK_E_NOOBJECT; |
| } |
| |
| static HRESULT WINAPI ShellItem_GetParent(IShellItem2 *iface, IShellItem **ppsi) |
| { |
| ShellItem *This = impl_from_IShellItem2(iface); |
| LPITEMIDLIST parent_pidl; |
| HRESULT ret; |
| |
| TRACE("(%p,%p)\n", iface, ppsi); |
| |
| ret = ShellItem_get_parent_pidl(This, &parent_pidl); |
| if (SUCCEEDED(ret)) |
| { |
| ret = SHCreateShellItem(NULL, NULL, parent_pidl, ppsi); |
| ILFree(parent_pidl); |
| } |
| |
| return ret; |
| } |
| |
| static HRESULT WINAPI ShellItem_GetDisplayName(IShellItem2 *iface, SIGDN sigdnName, |
| LPWSTR *ppszName) |
| { |
| ShellItem *This = impl_from_IShellItem2(iface); |
| TRACE("(%p,%x,%p)\n", iface, sigdnName, ppszName); |
| |
| return SHGetNameFromIDList(This->pidl, sigdnName, ppszName); |
| } |
| |
| static HRESULT WINAPI ShellItem_GetAttributes(IShellItem2 *iface, SFGAOF sfgaoMask, |
| SFGAOF *psfgaoAttribs) |
| { |
| ShellItem *This = impl_from_IShellItem2(iface); |
| IShellFolder *parent_folder; |
| LPITEMIDLIST child_pidl; |
| HRESULT ret; |
| |
| TRACE("(%p,%x,%p)\n", iface, sfgaoMask, psfgaoAttribs); |
| |
| if (_ILIsDesktop(This->pidl)) |
| ret = SHGetDesktopFolder(&parent_folder); |
| else |
| ret = ShellItem_get_parent_shellfolder(This, &parent_folder); |
| if (SUCCEEDED(ret)) |
| { |
| child_pidl = ILFindLastID(This->pidl); |
| *psfgaoAttribs = sfgaoMask; |
| ret = IShellFolder_GetAttributesOf(parent_folder, 1, (LPCITEMIDLIST*)&child_pidl, psfgaoAttribs); |
| IShellFolder_Release(parent_folder); |
| } |
| |
| return ret; |
| } |
| |
| static HRESULT WINAPI ShellItem_Compare(IShellItem2 *iface, IShellItem *oth, |
| SICHINTF hint, int *piOrder) |
| { |
| LPWSTR dispname, dispname_oth; |
| HRESULT ret; |
| TRACE("(%p,%p,%x,%p)\n", iface, oth, hint, piOrder); |
| |
| if(hint & (SICHINT_CANONICAL | SICHINT_ALLFIELDS)) |
| FIXME("Unsupported flags 0x%08x\n", hint); |
| |
| ret = IShellItem2_GetDisplayName(iface, SIGDN_DESKTOPABSOLUTEEDITING, &dispname); |
| if(SUCCEEDED(ret)) |
| { |
| ret = IShellItem_GetDisplayName(oth, SIGDN_DESKTOPABSOLUTEEDITING, &dispname_oth); |
| if(SUCCEEDED(ret)) |
| { |
| *piOrder = lstrcmpiW(dispname, dispname_oth); |
| CoTaskMemFree(dispname_oth); |
| } |
| CoTaskMemFree(dispname); |
| } |
| |
| if(SUCCEEDED(ret) && *piOrder && |
| (hint & SICHINT_TEST_FILESYSPATH_IF_NOT_EQUAL)) |
| { |
| LPWSTR dispname, dispname_oth; |
| |
| TRACE("Testing filesystem path.\n"); |
| ret = IShellItem2_GetDisplayName(iface, SIGDN_FILESYSPATH, &dispname); |
| if(SUCCEEDED(ret)) |
| { |
| ret = IShellItem_GetDisplayName(oth, SIGDN_FILESYSPATH, &dispname_oth); |
| if(SUCCEEDED(ret)) |
| { |
| *piOrder = lstrcmpiW(dispname, dispname_oth); |
| CoTaskMemFree(dispname_oth); |
| } |
| CoTaskMemFree(dispname); |
| } |
| } |
| |
| if(FAILED(ret)) |
| return ret; |
| |
| if(*piOrder) |
| return S_FALSE; |
| else |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI ShellItem2_GetPropertyStore(IShellItem2 *iface, GETPROPERTYSTOREFLAGS flags, |
| REFIID riid, void **ppv) |
| { |
| ShellItem *This = impl_from_IShellItem2(iface); |
| FIXME("Stub: %p (%d, %s, %p)\n", This, flags, shdebugstr_guid(riid), ppv); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI ShellItem2_GetPropertyStoreWithCreateObject(IShellItem2 *iface, |
| GETPROPERTYSTOREFLAGS flags, IUnknown *punkCreateObject, REFIID riid, void **ppv) |
| { |
| ShellItem *This = impl_from_IShellItem2(iface); |
| FIXME("Stub: %p (%08x, %p, %s, %p)\n", |
| This, flags, punkCreateObject, shdebugstr_guid(riid), ppv); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI ShellItem2_GetPropertyStoreForKeys(IShellItem2 *iface, const PROPERTYKEY *rgKeys, |
| UINT cKeys, GETPROPERTYSTOREFLAGS flags, REFIID riid, void **ppv) |
| { |
| ShellItem *This = impl_from_IShellItem2(iface); |
| FIXME("Stub: %p (%p, %d, %08x, %s, %p)\n", |
| This, rgKeys, cKeys, flags, shdebugstr_guid(riid), ppv); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI ShellItem2_GetPropertyDescriptionList(IShellItem2 *iface, |
| REFPROPERTYKEY keyType, REFIID riid, void **ppv) |
| { |
| ShellItem *This = impl_from_IShellItem2(iface); |
| FIXME("Stub: %p (%p, %s, %p)\n", This, keyType, debugstr_guid(riid), ppv); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI ShellItem2_Update(IShellItem2 *iface, IBindCtx *pbc) |
| { |
| ShellItem *This = impl_from_IShellItem2(iface); |
| FIXME("Stub: %p (%p)\n", This, pbc); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI ShellItem2_GetProperty(IShellItem2 *iface, REFPROPERTYKEY key, PROPVARIANT *ppropvar) |
| { |
| ShellItem *This = impl_from_IShellItem2(iface); |
| FIXME("Stub: %p (%p, %p)\n", This, key, ppropvar); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI ShellItem2_GetCLSID(IShellItem2 *iface, REFPROPERTYKEY key, CLSID *pclsid) |
| { |
| ShellItem *This = impl_from_IShellItem2(iface); |
| FIXME("Stub: %p (%p, %p)\n", This, key, pclsid); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI ShellItem2_GetFileTime(IShellItem2 *iface, REFPROPERTYKEY key, FILETIME *pft) |
| { |
| ShellItem *This = impl_from_IShellItem2(iface); |
| FIXME("Stub: %p (%p, %p)\n", This, key, pft); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI ShellItem2_GetInt32(IShellItem2 *iface, REFPROPERTYKEY key, int *pi) |
| { |
| ShellItem *This = impl_from_IShellItem2(iface); |
| FIXME("Stub: %p (%p, %p)\n", This, key, pi); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI ShellItem2_GetString(IShellItem2 *iface, REFPROPERTYKEY key, LPWSTR *ppsz) |
| { |
| ShellItem *This = impl_from_IShellItem2(iface); |
| FIXME("Stub: %p (%p, %p)\n", This, key, ppsz); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI ShellItem2_GetUInt32(IShellItem2 *iface, REFPROPERTYKEY key, ULONG *pui) |
| { |
| ShellItem *This = impl_from_IShellItem2(iface); |
| FIXME("Stub: %p (%p, %p)\n", This, key, pui); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI ShellItem2_GetUInt64(IShellItem2 *iface, REFPROPERTYKEY key, ULONGLONG *pull) |
| { |
| ShellItem *This = impl_from_IShellItem2(iface); |
| FIXME("Stub: %p (%p, %p)\n", This, key, pull); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI ShellItem2_GetBool(IShellItem2 *iface, REFPROPERTYKEY key, BOOL *pf) |
| { |
| ShellItem *This = impl_from_IShellItem2(iface); |
| FIXME("Stub: %p (%p, %p)\n", This, key, pf); |
| return E_NOTIMPL; |
| } |
| |
| |
| static const IShellItem2Vtbl ShellItem2_Vtbl = { |
| ShellItem_QueryInterface, |
| ShellItem_AddRef, |
| ShellItem_Release, |
| ShellItem_BindToHandler, |
| ShellItem_GetParent, |
| ShellItem_GetDisplayName, |
| ShellItem_GetAttributes, |
| ShellItem_Compare, |
| ShellItem2_GetPropertyStore, |
| ShellItem2_GetPropertyStoreWithCreateObject, |
| ShellItem2_GetPropertyStoreForKeys, |
| ShellItem2_GetPropertyDescriptionList, |
| ShellItem2_Update, |
| ShellItem2_GetProperty, |
| ShellItem2_GetCLSID, |
| ShellItem2_GetFileTime, |
| ShellItem2_GetInt32, |
| ShellItem2_GetString, |
| ShellItem2_GetUInt32, |
| ShellItem2_GetUInt64, |
| ShellItem2_GetBool |
| }; |
| |
| |
| static HRESULT ShellItem_GetClassID(ShellItem* This, CLSID *pClassID) |
| { |
| TRACE("(%p,%p)\n", This, pClassID); |
| |
| *pClassID = CLSID_ShellItem; |
| return S_OK; |
| } |
| |
| |
| static HRESULT WINAPI ShellItem_IPersistIDList_QueryInterface(IPersistIDList *iface, |
| REFIID riid, void **ppv) |
| { |
| ShellItem *This = impl_from_IPersistIDList(iface); |
| return ShellItem_QueryInterface(&This->IShellItem2_iface, riid, ppv); |
| } |
| |
| static ULONG WINAPI ShellItem_IPersistIDList_AddRef(IPersistIDList *iface) |
| { |
| ShellItem *This = impl_from_IPersistIDList(iface); |
| return ShellItem_AddRef(&This->IShellItem2_iface); |
| } |
| |
| static ULONG WINAPI ShellItem_IPersistIDList_Release(IPersistIDList *iface) |
| { |
| ShellItem *This = impl_from_IPersistIDList(iface); |
| return ShellItem_Release(&This->IShellItem2_iface); |
| } |
| |
| static HRESULT WINAPI ShellItem_IPersistIDList_GetClassID(IPersistIDList* iface, |
| CLSID *pClassID) |
| { |
| ShellItem *This = impl_from_IPersistIDList(iface); |
| |
| return ShellItem_GetClassID(This, pClassID); |
| } |
| |
| static HRESULT WINAPI ShellItem_IPersistIDList_SetIDList(IPersistIDList* iface, |
| LPCITEMIDLIST pidl) |
| { |
| ShellItem *This = impl_from_IPersistIDList(iface); |
| LPITEMIDLIST new_pidl; |
| |
| TRACE("(%p,%p)\n", This, pidl); |
| |
| new_pidl = ILClone(pidl); |
| |
| if (new_pidl) |
| { |
| ILFree(This->pidl); |
| This->pidl = new_pidl; |
| return S_OK; |
| } |
| else |
| return E_OUTOFMEMORY; |
| } |
| |
| static HRESULT WINAPI ShellItem_IPersistIDList_GetIDList(IPersistIDList* iface, |
| LPITEMIDLIST *ppidl) |
| { |
| ShellItem *This = impl_from_IPersistIDList(iface); |
| |
| TRACE("(%p,%p)\n", This, ppidl); |
| |
| *ppidl = ILClone(This->pidl); |
| if (*ppidl) |
| return S_OK; |
| else |
| return E_OUTOFMEMORY; |
| } |
| |
| static const IPersistIDListVtbl ShellItem_IPersistIDList_Vtbl = { |
| ShellItem_IPersistIDList_QueryInterface, |
| ShellItem_IPersistIDList_AddRef, |
| ShellItem_IPersistIDList_Release, |
| ShellItem_IPersistIDList_GetClassID, |
| ShellItem_IPersistIDList_SetIDList, |
| ShellItem_IPersistIDList_GetIDList |
| }; |
| |
| |
| HRESULT WINAPI IShellItem_Constructor(IUnknown *pUnkOuter, REFIID riid, void **ppv) |
| { |
| ShellItem *This; |
| HRESULT ret; |
| |
| TRACE("(%p,%s)\n",pUnkOuter, debugstr_guid(riid)); |
| |
| *ppv = NULL; |
| |
| if (pUnkOuter) return CLASS_E_NOAGGREGATION; |
| |
| This = HeapAlloc(GetProcessHeap(), 0, sizeof(ShellItem)); |
| This->IShellItem2_iface.lpVtbl = &ShellItem2_Vtbl; |
| This->ref = 1; |
| This->pidl = NULL; |
| This->IPersistIDList_iface.lpVtbl = &ShellItem_IPersistIDList_Vtbl; |
| |
| ret = ShellItem_QueryInterface(&This->IShellItem2_iface, riid, ppv); |
| ShellItem_Release(&This->IShellItem2_iface); |
| |
| return ret; |
| } |
| |
| HRESULT WINAPI SHCreateShellItem(LPCITEMIDLIST pidlParent, |
| IShellFolder *psfParent, LPCITEMIDLIST pidl, IShellItem **ppsi) |
| { |
| ShellItem *This; |
| LPITEMIDLIST new_pidl; |
| HRESULT ret; |
| |
| TRACE("(%p,%p,%p,%p)\n", pidlParent, psfParent, pidl, ppsi); |
| |
| if (!pidl) |
| { |
| return E_INVALIDARG; |
| } |
| else if (pidlParent || psfParent) |
| { |
| LPITEMIDLIST temp_parent=NULL; |
| if (!pidlParent) |
| { |
| IPersistFolder2* ppf2Parent; |
| |
| if (FAILED(IShellFolder_QueryInterface(psfParent, &IID_IPersistFolder2, (void**)&ppf2Parent))) |
| { |
| FIXME("couldn't get IPersistFolder2 interface of parent\n"); |
| return E_NOINTERFACE; |
| } |
| |
| if (FAILED(IPersistFolder2_GetCurFolder(ppf2Parent, &temp_parent))) |
| { |
| FIXME("couldn't get parent PIDL\n"); |
| IPersistFolder2_Release(ppf2Parent); |
| return E_NOINTERFACE; |
| } |
| |
| pidlParent = temp_parent; |
| IPersistFolder2_Release(ppf2Parent); |
| } |
| |
| 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; |
| } |
| |
| ret = IShellItem_Constructor(NULL, &IID_IShellItem, (void**)&This); |
| if (This) |
| { |
| *ppsi = (IShellItem*)&This->IShellItem2_iface; |
| This->pidl = new_pidl; |
| } |
| else |
| { |
| *ppsi = NULL; |
| ILFree(new_pidl); |
| } |
| return ret; |
| } |
| |
| HRESULT WINAPI SHCreateItemFromParsingName(PCWSTR pszPath, |
| IBindCtx *pbc, REFIID riid, void **ppv) |
| { |
| LPITEMIDLIST pidl; |
| HRESULT ret; |
| |
| *ppv = NULL; |
| |
| ret = SHParseDisplayName(pszPath, pbc, &pidl, 0, NULL); |
| if(SUCCEEDED(ret)) |
| { |
| ShellItem *This; |
| ret = IShellItem_Constructor(NULL, riid, (void**)&This); |
| |
| if(SUCCEEDED(ret)) |
| { |
| This->pidl = pidl; |
| *ppv = (void*)This; |
| } |
| else |
| { |
| ILFree(pidl); |
| } |
| } |
| return ret; |
| } |
| |
| HRESULT WINAPI SHCreateItemFromIDList(PCIDLIST_ABSOLUTE pidl, REFIID riid, void **ppv) |
| { |
| ShellItem *psiimpl; |
| HRESULT ret; |
| |
| if(!pidl) |
| return E_INVALIDARG; |
| |
| ret = IShellItem_Constructor(NULL, riid, ppv); |
| if(SUCCEEDED(ret)) |
| { |
| psiimpl = (ShellItem*)*ppv; |
| psiimpl->pidl = ILClone(pidl); |
| } |
| |
| return ret; |
| } |
| |
| HRESULT WINAPI SHGetItemFromDataObject(IDataObject *pdtobj, |
| DATAOBJ_GET_ITEM_FLAGS dwFlags, REFIID riid, void **ppv) |
| { |
| FORMATETC fmt; |
| STGMEDIUM medium; |
| HRESULT ret; |
| |
| TRACE("%p, %x, %s, %p\n", pdtobj, dwFlags, debugstr_guid(riid), ppv); |
| |
| if(!pdtobj) |
| return E_INVALIDARG; |
| |
| fmt.cfFormat = RegisterClipboardFormatW(CFSTR_SHELLIDLISTW); |
| fmt.ptd = NULL; |
| fmt.dwAspect = DVASPECT_CONTENT; |
| fmt.lindex = -1; |
| fmt.tymed = TYMED_HGLOBAL; |
| |
| ret = IDataObject_GetData(pdtobj, &fmt, &medium); |
| if(SUCCEEDED(ret)) |
| { |
| LPIDA pida = GlobalLock(medium.u.hGlobal); |
| |
| if((pida->cidl > 1 && !(dwFlags & DOGIF_ONLY_IF_ONE)) || |
| pida->cidl == 1) |
| { |
| LPITEMIDLIST pidl; |
| |
| /* Get the first pidl (parent + child1) */ |
| pidl = ILCombine((LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[0]), |
| (LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[1])); |
| |
| ret = SHCreateItemFromIDList(pidl, riid, ppv); |
| ILFree(pidl); |
| } |
| else |
| { |
| ret = E_FAIL; |
| } |
| |
| GlobalUnlock(medium.u.hGlobal); |
| GlobalFree(medium.u.hGlobal); |
| } |
| |
| if(FAILED(ret) && !(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; |
| |
| ret = IDataObject_GetData(pdtobj, &fmt, &medium); |
| if(SUCCEEDED(ret)) |
| { |
| DROPFILES *df = GlobalLock(medium.u.hGlobal); |
| LPBYTE files = (LPBYTE)df + df->pFiles; |
| BOOL multiple_files = FALSE; |
| |
| ret = E_FAIL; |
| if(!df->fWide) |
| { |
| WCHAR filename[MAX_PATH]; |
| PCSTR first_file = (PCSTR)files; |
| if(*(files + lstrlenA(first_file) + 1) != 0) |
| multiple_files = TRUE; |
| |
| if( !(multiple_files && (dwFlags & DOGIF_ONLY_IF_ONE)) ) |
| { |
| MultiByteToWideChar(CP_ACP, 0, first_file, -1, filename, MAX_PATH); |
| ret = SHCreateItemFromParsingName(filename, NULL, riid, ppv); |
| } |
| } |
| else |
| { |
| PCWSTR first_file = (PCWSTR)files; |
| if(*((PCWSTR)files + lstrlenW(first_file) + 1) != 0) |
| multiple_files = TRUE; |
| |
| if( !(multiple_files && (dwFlags & DOGIF_ONLY_IF_ONE)) ) |
| ret = SHCreateItemFromParsingName(first_file, NULL, riid, ppv); |
| } |
| |
| GlobalUnlock(medium.u.hGlobal); |
| GlobalFree(medium.u.hGlobal); |
| } |
| } |
| |
| if(FAILED(ret) && !(dwFlags & DOGIF_NO_URL)) |
| { |
| FIXME("Failed to create item, should try CF_URL.\n"); |
| } |
| |
| return ret; |
| } |
| |
| HRESULT WINAPI SHGetItemFromObject(IUnknown *punk, REFIID riid, void **ppv) |
| { |
| LPITEMIDLIST pidl; |
| HRESULT ret; |
| |
| ret = SHGetIDListFromObject(punk, &pidl); |
| if(SUCCEEDED(ret)) |
| { |
| ret = SHCreateItemFromIDList(pidl, riid, ppv); |
| ILFree(pidl); |
| } |
| |
| return ret; |
| } |
| |
| /************************************************************************* |
| * IShellItemArray implementation |
| */ |
| typedef struct { |
| IShellItemArray IShellItemArray_iface; |
| LONG ref; |
| |
| IShellItem **array; |
| DWORD item_count; |
| } IShellItemArrayImpl; |
| |
| static inline IShellItemArrayImpl *impl_from_IShellItemArray(IShellItemArray *iface) |
| { |
| return CONTAINING_RECORD(iface, IShellItemArrayImpl, IShellItemArray_iface); |
| } |
| |
| static HRESULT WINAPI IShellItemArray_fnQueryInterface(IShellItemArray *iface, |
| REFIID riid, |
| void **ppvObject) |
| { |
| IShellItemArrayImpl *This = impl_from_IShellItemArray(iface); |
| TRACE("%p (%s, %p)\n", This, shdebugstr_guid(riid), ppvObject); |
| |
| *ppvObject = NULL; |
| if(IsEqualIID(riid, &IID_IShellItemArray) || |
| IsEqualIID(riid, &IID_IUnknown)) |
| { |
| *ppvObject = This; |
| } |
| |
| if(*ppvObject) |
| { |
| IUnknown_AddRef((IUnknown*)*ppvObject); |
| return S_OK; |
| } |
| |
| return E_NOINTERFACE; |
| } |
| |
| static ULONG WINAPI IShellItemArray_fnAddRef(IShellItemArray *iface) |
| { |
| IShellItemArrayImpl *This = impl_from_IShellItemArray(iface); |
| LONG ref = InterlockedIncrement(&This->ref); |
| TRACE("%p - ref %d\n", This, ref); |
| |
| return ref; |
| } |
| |
| static ULONG WINAPI IShellItemArray_fnRelease(IShellItemArray *iface) |
| { |
| IShellItemArrayImpl *This = impl_from_IShellItemArray(iface); |
| LONG ref = InterlockedDecrement(&This->ref); |
| TRACE("%p - ref %d\n", This, ref); |
| |
| if(!ref) |
| { |
| UINT i; |
| TRACE("Freeing.\n"); |
| |
| for(i = 0; i < This->item_count; i++) |
| IShellItem_Release(This->array[i]); |
| |
| HeapFree(GetProcessHeap(), 0, This->array); |
| HeapFree(GetProcessHeap(), 0, This); |
| return 0; |
| } |
| |
| return ref; |
| } |
| |
| static HRESULT WINAPI IShellItemArray_fnBindToHandler(IShellItemArray *iface, |
| IBindCtx *pbc, |
| REFGUID bhid, |
| REFIID riid, |
| void **ppvOut) |
| { |
| IShellItemArrayImpl *This = impl_from_IShellItemArray(iface); |
| FIXME("Stub: %p (%p, %s, %s, %p)\n", |
| This, pbc, shdebugstr_guid(bhid), shdebugstr_guid(riid), ppvOut); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI IShellItemArray_fnGetPropertyStore(IShellItemArray *iface, |
| GETPROPERTYSTOREFLAGS flags, |
| REFIID riid, |
| void **ppv) |
| { |
| IShellItemArrayImpl *This = impl_from_IShellItemArray(iface); |
| FIXME("Stub: %p (%x, %s, %p)\n", This, flags, shdebugstr_guid(riid), ppv); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI IShellItemArray_fnGetPropertyDescriptionList(IShellItemArray *iface, |
| REFPROPERTYKEY keyType, |
| REFIID riid, |
| void **ppv) |
| { |
| IShellItemArrayImpl *This = impl_from_IShellItemArray(iface); |
| FIXME("Stub: %p (%p, %s, %p)\n", |
| This, keyType, shdebugstr_guid(riid), ppv); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI IShellItemArray_fnGetAttributes(IShellItemArray *iface, |
| SIATTRIBFLAGS AttribFlags, |
| SFGAOF sfgaoMask, |
| SFGAOF *psfgaoAttribs) |
| { |
| IShellItemArrayImpl *This = impl_from_IShellItemArray(iface); |
| FIXME("Stub: %p (%x, %x, %p)\n", This, AttribFlags, sfgaoMask, psfgaoAttribs); |
| |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI IShellItemArray_fnGetCount(IShellItemArray *iface, |
| DWORD *pdwNumItems) |
| { |
| IShellItemArrayImpl *This = impl_from_IShellItemArray(iface); |
| TRACE("%p (%p)\n", This, pdwNumItems); |
| |
| *pdwNumItems = This->item_count; |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI IShellItemArray_fnGetItemAt(IShellItemArray *iface, |
| DWORD dwIndex, |
| IShellItem **ppsi) |
| { |
| IShellItemArrayImpl *This = impl_from_IShellItemArray(iface); |
| TRACE("%p (%x, %p)\n", This, dwIndex, ppsi); |
| |
| /* zero indexed */ |
| if(dwIndex + 1 > This->item_count) |
| return E_FAIL; |
| |
| *ppsi = This->array[dwIndex]; |
| IShellItem_AddRef(*ppsi); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI IShellItemArray_fnEnumItems(IShellItemArray *iface, |
| IEnumShellItems **ppenumShellItems) |
| { |
| IShellItemArrayImpl *This = impl_from_IShellItemArray(iface); |
| FIXME("Stub: %p (%p)\n", This, ppenumShellItems); |
| |
| return E_NOTIMPL; |
| } |
| |
| static const IShellItemArrayVtbl vt_IShellItemArray = { |
| IShellItemArray_fnQueryInterface, |
| IShellItemArray_fnAddRef, |
| IShellItemArray_fnRelease, |
| IShellItemArray_fnBindToHandler, |
| IShellItemArray_fnGetPropertyStore, |
| IShellItemArray_fnGetPropertyDescriptionList, |
| IShellItemArray_fnGetAttributes, |
| IShellItemArray_fnGetCount, |
| IShellItemArray_fnGetItemAt, |
| IShellItemArray_fnEnumItems |
| }; |
| |
| static HRESULT IShellItemArray_Constructor(IUnknown *pUnkOuter, REFIID riid, void **ppv) |
| { |
| IShellItemArrayImpl *This; |
| HRESULT ret; |
| |
| TRACE("(%p, %s, %p)\n",pUnkOuter, debugstr_guid(riid), ppv); |
| |
| if(pUnkOuter) |
| return CLASS_E_NOAGGREGATION; |
| |
| This = HeapAlloc(GetProcessHeap(), 0, sizeof(IShellItemArrayImpl)); |
| if(!This) |
| return E_OUTOFMEMORY; |
| |
| This->ref = 1; |
| This->IShellItemArray_iface.lpVtbl = &vt_IShellItemArray; |
| This->array = NULL; |
| This->item_count = 0; |
| |
| ret = IShellItemArray_QueryInterface(&This->IShellItemArray_iface, riid, ppv); |
| IShellItemArray_Release(&This->IShellItemArray_iface); |
| |
| return ret; |
| } |
| |
| HRESULT WINAPI SHCreateShellItemArray(PCIDLIST_ABSOLUTE pidlParent, |
| IShellFolder *psf, |
| UINT cidl, |
| PCUITEMID_CHILD_ARRAY ppidl, |
| IShellItemArray **ppsiItemArray) |
| { |
| IShellItemArrayImpl *This; |
| IShellItem **array; |
| HRESULT ret = E_FAIL; |
| UINT i; |
| |
| TRACE("%p, %p, %d, %p, %p\n", pidlParent, psf, cidl, ppidl, ppsiItemArray); |
| |
| if(!pidlParent && !psf) |
| return E_POINTER; |
| |
| if(!ppidl) |
| return E_INVALIDARG; |
| |
| array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cidl*sizeof(IShellItem*)); |
| if(!array) |
| return E_OUTOFMEMORY; |
| |
| for(i = 0; i < cidl; i++) |
| { |
| ret = SHCreateShellItem(pidlParent, psf, ppidl[i], &array[i]); |
| if(FAILED(ret)) break; |
| } |
| |
| if(SUCCEEDED(ret)) |
| { |
| ret = IShellItemArray_Constructor(NULL, &IID_IShellItemArray, (void**)&This); |
| if(SUCCEEDED(ret)) |
| { |
| This->array = array; |
| This->item_count = cidl; |
| *ppsiItemArray = &This->IShellItemArray_iface; |
| |
| return ret; |
| } |
| } |
| |
| /* Something failed, clean up. */ |
| for(i = 0; i < cidl; i++) |
| if(array[i]) IShellItem_Release(array[i]); |
| HeapFree(GetProcessHeap(), 0, array); |
| *ppsiItemArray = NULL; |
| return ret; |
| } |
| |
| HRESULT WINAPI SHCreateShellItemArrayFromShellItem(IShellItem *psi, REFIID riid, void **ppv) |
| { |
| IShellItemArrayImpl *This; |
| IShellItem **array; |
| HRESULT ret; |
| |
| TRACE("%p, %s, %p\n", psi, shdebugstr_guid(riid), ppv); |
| |
| array = HeapAlloc(GetProcessHeap(), 0, sizeof(IShellItem*)); |
| if(!array) |
| return E_OUTOFMEMORY; |
| |
| ret = IShellItemArray_Constructor(NULL, riid, (void**)&This); |
| if(SUCCEEDED(ret)) |
| { |
| array[0] = psi; |
| IShellItem_AddRef(psi); |
| This->array = array; |
| This->item_count = 1; |
| *ppv = This; |
| } |
| else |
| { |
| HeapFree(GetProcessHeap(), 0, array); |
| *ppv = NULL; |
| } |
| |
| return ret; |
| } |
| |
| HRESULT WINAPI SHCreateShellItemArrayFromDataObject(IDataObject *pdo, REFIID riid, void **ppv) |
| { |
| IShellItemArray *psia; |
| FORMATETC fmt; |
| STGMEDIUM medium; |
| HRESULT ret; |
| |
| TRACE("%p, %s, %p\n", pdo, shdebugstr_guid(riid), ppv); |
| |
| if(!pdo) |
| return E_INVALIDARG; |
| |
| *ppv = NULL; |
| |
| fmt.cfFormat = RegisterClipboardFormatW(CFSTR_SHELLIDLISTW); |
| fmt.ptd = NULL; |
| fmt.dwAspect = DVASPECT_CONTENT; |
| fmt.lindex = -1; |
| fmt.tymed = TYMED_HGLOBAL; |
| |
| ret = IDataObject_GetData(pdo, &fmt, &medium); |
| if(SUCCEEDED(ret)) |
| { |
| LPIDA pida = GlobalLock(medium.u.hGlobal); |
| LPCITEMIDLIST parent_pidl; |
| LPCITEMIDLIST *children; |
| UINT i; |
| TRACE("Converting %d objects.\n", pida->cidl); |
| |
| parent_pidl = (LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[0]); |
| |
| children = HeapAlloc(GetProcessHeap(), 0, sizeof(LPCITEMIDLIST)*pida->cidl); |
| for(i = 0; i < pida->cidl; i++) |
| children[i] = (LPCITEMIDLIST) ((LPBYTE)pida+pida->aoffset[i+1]); |
| |
| ret = SHCreateShellItemArray(parent_pidl, NULL, pida->cidl, children, &psia); |
| |
| HeapFree(GetProcessHeap(), 0, children); |
| |
| GlobalUnlock(medium.u.hGlobal); |
| GlobalFree(medium.u.hGlobal); |
| } |
| |
| if(SUCCEEDED(ret)) |
| { |
| ret = IShellItemArray_QueryInterface(psia, riid, ppv); |
| IShellItemArray_Release(psia); |
| } |
| |
| return ret; |
| } |
