HRESULT WINAPI SHCreateDefaultContextMenu(const DEFCONTEXTMENU *pdcm, REFIID riid, void **ppv)
{
IShellFolder *folder=pdcm->psf;
LPITEMIDLIST folder_pidl;
HRESULT ret;
IContextMenu *system_menu;
TRACE("(%p,%s,%p)\n",pdcm,shdebugstr_guid(riid),ppv);
if(!pdcm->pidlFolder)
{
IPersistFolder2 *persist;
IShellFolder_QueryInterface(folder,&IID_IPersistFolder2,(void**)&persist);
IPersistFolder2_GetCurFolder(persist,&folder_pidl);
IPersistFolder2_Release(persist);
}
else
folder_pidl=ILClone(pdcm->pidlFolder);
if(pdcm->cKeys==0)
FIXME("Loading shell extensions using IQueryAssociations not yet supported\n");
ItemMenu_Constructor(folder, folder_pidl, (const LPCITEMIDLIST*)pdcm->apidl, pdcm->cidl, &IID_IContextMenu, (void**)&system_menu);
ret = SHELL_CreateContextMenu(pdcm->hwnd,system_menu,folder,folder_pidl,(LPCITEMIDLIST*)pdcm->apidl,pdcm->cidl,pdcm->aKeys,pdcm->cKeys,riid,ppv);
IContextMenu_Release(system_menu);
ILFree(folder_pidl);
return ret;
}
HRESULT WINAPI CDefFolderMenu_Create2(LPCITEMIDLIST pidlFolder, HWND hwnd, UINT cidl,
LPCITEMIDLIST *apidl, IShellFolder *psf,
LPFNDFMCALLBACK lpfn, UINT nKeys, const HKEY *ahkeys,
IContextMenu **ppcm)
{
IContextMenu *system_menu;
HRESULT hres;
LPITEMIDLIST folder_pidl;
TRACE("(%p,%p,%u,%p,%p,%u,%p,%p)\n",pidlFolder,hwnd,cidl,apidl,psf,nKeys,ahkeys,ppcm);
if(!pidlFolder)
{
IPersistFolder2 *persist;
IShellFolder_QueryInterface(psf,&IID_IPersistFolder2,(void**)&persist);
IPersistFolder2_GetCurFolder(persist,&folder_pidl);
IPersistFolder2_Release(persist);
}
else
folder_pidl=ILClone(pidlFolder);
ItemMenu_Constructor(psf, folder_pidl, (const LPCITEMIDLIST*)apidl, cidl, &IID_IContextMenu, (void**)&system_menu);
hres= SHELL_CreateContextMenu(hwnd,system_menu,psf,folder_pidl,apidl,cidl,ahkeys,nKeys,&IID_IContextMenu,(void**)ppcm);
IContextMenu_Release(system_menu);
ILFree(folder_pidl);
return hres;
}
static void DoNewFolder(ContextMenu *This, IShellView *view)
{
ISFHelper *helper;
IShellFolder_QueryInterface(This->parent, &IID_ISFHelper, (void**)&helper);
if (helper)
{
WCHAR nameW[MAX_PATH];
LPITEMIDLIST pidl;
ISFHelper_GetUniqueName(helper, nameW, MAX_PATH);
ISFHelper_AddFolder(helper, 0, nameW, &pidl);
if (view)
{
/* if we are in a shellview do labeledit */
IShellView_SelectItem(view,
pidl,(SVSI_DESELECTOTHERS | SVSI_EDIT | SVSI_ENSUREVISIBLE
|SVSI_FOCUSED|SVSI_SELECT));
}
SHFree(pidl);
ISFHelper_Release(helper);
}
}
/**************************************************************************
* ISF_Fonts_fnGetUIObjectOf
*
* PARAMETERS
* hwndOwner [in] Parent window for any output
* cidl [in] array size
* apidl [in] simple pidl array
* riid [in] Requested Interface
* prgfInOut [ ] reserved
* ppvObject [out] Resulting Interface
*
*/
static HRESULT WINAPI ISF_Fonts_fnGetUIObjectOf (IShellFolder2 * iface,
HWND hwndOwner, UINT cidl, LPCITEMIDLIST * apidl, REFIID riid,
UINT * prgfInOut, LPVOID * ppvOut)
{
IGenericSFImpl *This = (IGenericSFImpl *)iface;
LPITEMIDLIST pidl;
IUnknown *pObj = NULL;
HRESULT hr = E_INVALIDARG;
TRACE ("(%p)->(%p,%u,apidl=%p,%s,%p,%p)\n", This,
hwndOwner, cidl, apidl, shdebugstr_guid (riid), prgfInOut, ppvOut);
if (!ppvOut)
return hr;
*ppvOut = NULL;
if (IsEqualIID (riid, &IID_IContextMenu) && (cidl >= 1))
{
pObj = (IUnknown*)(&This->lpVtblContextMenuFontItem);
This->apidl = apidl[0];
IUnknown_AddRef(pObj);
hr = S_OK;
}
else if (IsEqualIID (riid, &IID_IDataObject) && (cidl >= 1))
{
pObj = (LPUNKNOWN) IDataObject_Constructor (hwndOwner, This->pidlRoot, apidl, cidl);
hr = S_OK;
}
else if (IsEqualIID (riid, &IID_IExtractIconA) && (cidl == 1))
{
pidl = ILCombine (This->pidlRoot, apidl[0]);
pObj = (LPUNKNOWN) IExtractIconA_Constructor (pidl);
SHFree (pidl);
hr = S_OK;
}
else if (IsEqualIID (riid, &IID_IExtractIconW) && (cidl == 1))
{
pidl = ILCombine (This->pidlRoot, apidl[0]);
pObj = (LPUNKNOWN) IExtractIconW_Constructor (pidl);
SHFree (pidl);
hr = S_OK;
}
else if (IsEqualIID (riid, &IID_IDropTarget) && (cidl >= 1))
{
hr = IShellFolder_QueryInterface (iface, &IID_IDropTarget, (LPVOID *) & pObj);
}
else
hr = E_NOINTERFACE;
if (SUCCEEDED(hr) && !pObj)
hr = E_OUTOFMEMORY;
*ppvOut = pObj;
TRACE ("(%p)->hr=0x%08x\n", This, hr);
return hr;
}
HRESULT WINAPI SHCreateShellItem(LPCITEMIDLIST pidlParent,
IShellFolder *psfParent, LPCITEMIDLIST pidl, IShellItem **ppsi)
{
LPITEMIDLIST new_pidl;
HRESULT ret;
TRACE("(%p,%p,%p,%p)\n", pidlParent, psfParent, pidl, ppsi);
*ppsi = NULL;
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 = SHCreateItemFromIDList(new_pidl, &IID_IShellItem, (void**)ppsi);
ILFree(new_pidl);
return ret;
}
/**************************************************************************
* DoDelete
*
* deletes the currently selected items
*/
static void DoDelete(ItemCmImpl *This)
{
ISFHelper * psfhlp;
IShellFolder_QueryInterface(This->pSFParent, &IID_ISFHelper, (LPVOID*)&psfhlp);
if (psfhlp)
{
ISFHelper_DeleteItems(psfhlp, This->cidl, (LPCITEMIDLIST *)This->apidl);
ISFHelper_Release(psfhlp);
}
}
/**************************************************************************
* DoDelete
*
* deletes the currently selected items
*/
static void DoDelete(ContextMenu *This)
{
ISFHelper *helper;
IShellFolder_QueryInterface(This->parent, &IID_ISFHelper, (void**)&helper);
if (helper)
{
ISFHelper_DeleteItems(helper, This->cidl, (LPCITEMIDLIST*)This->apidl);
ISFHelper_Release(helper);
}
}
/**************************************************************************
* DoDelete
*
* deletes the currently selected items
*/
static void DoDelete(IContextMenu *iface)
{
ICOM_THIS(ItemCmImpl, iface);
ISFHelper * psfhlp;
IShellFolder_QueryInterface(This->pSFParent, &IID_ISFHelper, (LPVOID*)&psfhlp);
if (psfhlp)
{
ISFHelper_DeleteItems(psfhlp, This->cidl, This->apidl);
ISFHelper_Release(psfhlp);
}
}
static void test_desktop_folder(void)
{
IShellFolder *psf;
HRESULT hr;
hr = SHGetDesktopFolder(&psf);
ok(hr == S_OK, "Got %x\n", hr);
hr = IShellFolder_QueryInterface(psf, &IID_IShellFolder, NULL);
ok(hr == E_POINTER, "Got %x\n", hr);
IShellFolder_Release(psf);
}
static HRESULT create_folder(NewMenuImpl *This, IShellView *view)
{
IFolderView *folder_view = NULL;
IShellFolder *desktop = NULL;
IShellFolder *parent = NULL;
ISFHelper *helper = NULL;
LPITEMIDLIST pidl = NULL;
WCHAR nameW[MAX_PATH];
HRESULT hr;
if (view)
{
hr = IShellView_QueryInterface(view, &IID_IFolderView, (void **)&folder_view);
if (FAILED(hr)) return hr;
hr = IFolderView_GetFolder(folder_view, &IID_IShellFolder, (void **)&parent);
if (FAILED(hr)) goto out;
}
else
{
hr = SHGetDesktopFolder(&desktop);
if (FAILED(hr)) goto out;
hr = IShellFolder_BindToObject(desktop, This->pidl, NULL, &IID_IShellFolder, (void **)&parent);
if (FAILED(hr)) goto out;
}
IShellFolder_QueryInterface(parent, &IID_ISFHelper, (void **)&helper);
if (FAILED(hr)) goto out;
hr = ISFHelper_GetUniqueName(helper, nameW, MAX_PATH);
if (FAILED(hr)) goto out;
hr = ISFHelper_AddFolder(helper, 0, nameW, &pidl);
if (FAILED(hr)) goto out;
if (view)
{
IShellView_SelectItem(view, pidl, SVSI_DESELECTOTHERS | SVSI_EDIT |
SVSI_ENSUREVISIBLE | SVSI_FOCUSED | SVSI_SELECT);
}
out:
if (pidl) SHFree(pidl);
if (helper) ISFHelper_Release(helper);
if (parent) IShellFolder_Release(parent);
if (desktop) IShellFolder_Release(desktop);
if (folder_view) IFolderView_Release(folder_view);
return hr;
}
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;
}
/**************************************************************************
* ISF_Desktop_fnGetUIObjectOf
*
* PARAMETERS
* HWND hwndOwner, //[in ] Parent window for any output
* UINT cidl, //[in ] array size
* LPCITEMIDLIST* apidl, //[in ] simple pidl array
* REFIID riid, //[in ] Requested Interface
* UINT* prgfInOut, //[ ] reserved
* LPVOID* ppvObject) //[out] Resulting Interface
*
*/
static HRESULT WINAPI ISF_Desktop_fnGetUIObjectOf (IShellFolder2 * iface,
HWND hwndOwner, UINT cidl, LPCITEMIDLIST * apidl,
REFIID riid, UINT * prgfInOut, LPVOID * ppvOut)
{
IDesktopFolderImpl *This = impl_from_IShellFolder2(iface);
LPITEMIDLIST pidl;
IUnknown *pObj = NULL;
HRESULT hr = E_INVALIDARG;
TRACE ("(%p)->(%p,%u,apidl=%p,%s,%p,%p)\n",
This, hwndOwner, cidl, apidl, shdebugstr_guid (riid), prgfInOut, ppvOut);
if (!ppvOut)
return E_INVALIDARG;
*ppvOut = NULL;
if (IsEqualIID (riid, &IID_IContextMenu))
{
if (cidl > 0)
return ItemMenu_Constructor((IShellFolder*)iface, This->pidlRoot, apidl, cidl, riid, ppvOut);
else
return BackgroundMenu_Constructor((IShellFolder*)iface, TRUE, riid, ppvOut);
}
else if (IsEqualIID (riid, &IID_IDataObject) && (cidl >= 1))
{
pObj = (LPUNKNOWN) IDataObject_Constructor( hwndOwner,
This->pidlRoot, apidl, cidl);
hr = S_OK;
}
else if (IsEqualIID (riid, &IID_IExtractIconA) && (cidl == 1))
{
pidl = ILCombine (This->pidlRoot, apidl[0]);
pObj = (LPUNKNOWN) IExtractIconA_Constructor (pidl);
SHFree (pidl);
hr = S_OK;
}
else if (IsEqualIID (riid, &IID_IExtractIconW) && (cidl == 1))
{
pidl = ILCombine (This->pidlRoot, apidl[0]);
pObj = (LPUNKNOWN) IExtractIconW_Constructor (pidl);
SHFree (pidl);
hr = S_OK;
}
else if (IsEqualIID (riid, &IID_IDropTarget) && (cidl >= 1))
{
hr = IShellFolder_QueryInterface (iface,
&IID_IDropTarget, (LPVOID *) & pObj);
}
else if ((IsEqualIID(riid,&IID_IShellLinkW) ||
IsEqualIID(riid,&IID_IShellLinkA)) && (cidl == 1))
{
pidl = ILCombine (This->pidlRoot, apidl[0]);
hr = IShellLink_ConstructFromFile(NULL, riid, pidl, (LPVOID*)&pObj);
SHFree (pidl);
}
else
hr = E_NOINTERFACE;
if (SUCCEEDED(hr) && !pObj)
hr = E_OUTOFMEMORY;
*ppvOut = pObj;
TRACE ("(%p)->hr=0x%08x\n", This, hr);
return hr;
}
static BOOL DoPaste(ContextMenu *This)
{
BOOL bSuccess = FALSE;
IDataObject * pda;
TRACE("\n");
if(SUCCEEDED(OleGetClipboard(&pda)))
{
STGMEDIUM medium;
FORMATETC formatetc;
TRACE("pda=%p\n", pda);
/* Set the FORMATETC structure*/
InitFormatEtc(formatetc, RegisterClipboardFormatW(CFSTR_SHELLIDLISTW), TYMED_HGLOBAL);
/* Get the pidls from IDataObject */
if(SUCCEEDED(IDataObject_GetData(pda,&formatetc,&medium)))
{
LPITEMIDLIST * apidl;
LPITEMIDLIST pidl;
IShellFolder *psfFrom = NULL, *psfDesktop;
LPIDA lpcida = GlobalLock(medium.u.hGlobal);
TRACE("cida=%p\n", lpcida);
apidl = _ILCopyCidaToaPidl(&pidl, lpcida);
/* bind to the source shellfolder */
SHGetDesktopFolder(&psfDesktop);
if(psfDesktop)
{
IShellFolder_BindToObject(psfDesktop, pidl, NULL, &IID_IShellFolder, (LPVOID*)&psfFrom);
IShellFolder_Release(psfDesktop);
}
if (psfFrom)
{
/* get source and destination shellfolder */
ISFHelper *psfhlpdst, *psfhlpsrc;
IShellFolder_QueryInterface(This->parent, &IID_ISFHelper, (void**)&psfhlpdst);
IShellFolder_QueryInterface(psfFrom, &IID_ISFHelper, (void**)&psfhlpsrc);
/* do the copy/move */
if (psfhlpdst && psfhlpsrc)
{
ISFHelper_CopyItems(psfhlpdst, psfFrom, lpcida->cidl, (LPCITEMIDLIST*)apidl);
/* FIXME handle move
ISFHelper_DeleteItems(psfhlpsrc, lpcida->cidl, apidl);
*/
}
if(psfhlpdst) ISFHelper_Release(psfhlpdst);
if(psfhlpsrc) ISFHelper_Release(psfhlpsrc);
IShellFolder_Release(psfFrom);
}
_ILFreeaPidl(apidl, lpcida->cidl);
SHFree(pidl);
/* release the medium*/
ReleaseStgMedium(&medium);
}
IDataObject_Release(pda);
}
#if 0
HGLOBAL hMem;
OpenClipboard(NULL);
hMem = GetClipboardData(CF_HDROP);
if(hMem)
{
char * pDropFiles = GlobalLock(hMem);
if(pDropFiles)
{
int len, offset = sizeof(DROPFILESTRUCT);
while( pDropFiles[offset] != 0)
{
len = strlen(pDropFiles + offset);
TRACE("%s\n", pDropFiles + offset);
offset += len+1;
}
}
GlobalUnlock(hMem);
}
CloseClipboard();
#endif
return bSuccess;
}
static HRESULT WINAPI
ISF_Desktop_ISFHelper_fnCopyItems (ISFHelper * iface, IShellFolder * pSFFrom, UINT cidl, LPCITEMIDLIST * apidl)
{
IPersistFolder2 *ppf2 = NULL;
WCHAR szSrcPath[MAX_PATH];
WCHAR szTargetPath[MAX_PATH];
SHFILEOPSTRUCTW op;
LPITEMIDLIST pidl;
LPWSTR pszSrc, pszTarget, pszSrcList, pszTargetList, pszFileName;
int res, length;
STRRET strRet;
IGenericSFImpl *This = impl_from_ISFHelper(iface);
TRACE ("(%p)->(%p,%u,%p)\n", This, pSFFrom, cidl, apidl);
IShellFolder_QueryInterface (pSFFrom, &IID_IPersistFolder2, (LPVOID *) & ppf2);
if (ppf2)
{
if (FAILED(IPersistFolder2_GetCurFolder (ppf2, &pidl)))
{
IPersistFolder2_Release(ppf2);
return E_FAIL;
}
IPersistFolder2_Release(ppf2);
if (FAILED(IShellFolder_GetDisplayNameOf(pSFFrom, pidl, SHGDN_FORPARSING, &strRet)))
{
SHFree (pidl);
return E_FAIL;
}
if (FAILED(StrRetToBufW(&strRet, pidl, szSrcPath, MAX_PATH)))
{
SHFree (pidl);
return E_FAIL;
}
SHFree (pidl);
pszSrc = PathAddBackslashW (szSrcPath);
wcscpy(szTargetPath, This->sPathTarget);
pszTarget = PathAddBackslashW (szTargetPath);
pszSrcList = build_paths_list(szSrcPath, cidl, apidl);
pszTargetList = build_paths_list(szTargetPath, cidl, apidl);
if (!pszSrcList || !pszTargetList)
{
if (pszSrcList)
HeapFree(GetProcessHeap(), 0, pszSrcList);
if (pszTargetList)
HeapFree(GetProcessHeap(), 0, pszTargetList);
SHFree (pidl);
IPersistFolder2_Release (ppf2);
return E_OUTOFMEMORY;
}
ZeroMemory(&op, sizeof(op));
if (!pszSrcList[0])
{
/* remove trailing backslash */
pszSrc--;
pszSrc[0] = L'\0';
op.pFrom = szSrcPath;
}
else
{
op.pFrom = pszSrcList;
}
if (!pszTargetList[0])
{
/* remove trailing backslash */
if (pszTarget - szTargetPath > 3)
{
pszTarget--;
pszTarget[0] = L'\0';
}
else
{
pszTarget[1] = L'\0';
}
op.pTo = szTargetPath;
}
else
{
op.pTo = pszTargetList;
}
op.hwnd = GetActiveWindow();
op.wFunc = FO_COPY;
op.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMMKDIR;
res = SHFileOperationW(&op);
if (res == DE_SAMEFILE)
{
length = wcslen(szTargetPath);
pszFileName = wcsrchr(pszSrcList, '\\');
pszFileName++;
if (LoadStringW(shell32_hInstance, IDS_COPY_OF, pszTarget, MAX_PATH - length))
{
wcscat(szTargetPath, L" ");
}
wcscat(szTargetPath, pszFileName);
op.pTo = szTargetPath;
res = SHFileOperationW(&op);
}
HeapFree(GetProcessHeap(), 0, pszSrcList);
HeapFree(GetProcessHeap(), 0, pszTargetList);
if (res)
return E_FAIL;
else
return S_OK;
}
return E_FAIL;
}
static HRESULT BrsFolder_NewFolder(browse_info *info)
{
DWORD flags = BrowseFlagsToSHCONTF(info->lpBrowseInfo->ulFlags);
IShellFolder *desktop, *cur;
ISFHelper *sfhelper;
WCHAR name[MAX_PATH];
HTREEITEM parent, added;
LPTV_ITEMDATA item_data;
LPITEMIDLIST new_item;
TVITEMW item;
HRESULT hr;
int len;
if(!info->pidlRet) {
ERR("Make new folder button should be disabled\n");
return E_FAIL;
}
/* Create new directory */
hr = SHGetDesktopFolder(&desktop);
if(FAILED(hr))
return hr;
hr = IShellFolder_BindToObject(desktop, info->pidlRet, 0, &IID_IShellFolder, (void**)&cur);
IShellFolder_Release(desktop);
if(FAILED(hr))
return hr;
hr = IShellFolder_QueryInterface(cur, &IID_ISFHelper, (void**)&sfhelper);
if(FAILED(hr))
return hr;
hr = SHGetPathFromIDListW(info->pidlRet, name);
if(FAILED(hr))
goto cleanup;
len = strlenW(name);
if(len<MAX_PATH)
name[len++] = '\\';
hr = ISFHelper_GetUniqueName(sfhelper, &name[len], MAX_PATH-len);
ISFHelper_Release(sfhelper);
if(FAILED(hr))
goto cleanup;
hr = E_FAIL;
if(!CreateDirectoryW(name, NULL))
goto cleanup;
/* Update parent of newly created directory */
parent = (HTREEITEM)SendMessageW(info->hwndTreeView, TVM_GETNEXTITEM, TVGN_CARET, 0);
if(!parent)
goto cleanup;
SendMessageW(info->hwndTreeView, TVM_EXPAND, TVE_EXPAND, (LPARAM)parent);
memset(&item, 0, sizeof(TVITEMW));
item.mask = TVIF_PARAM|TVIF_STATE;
item.hItem = parent;
SendMessageW(info->hwndTreeView, TVM_GETITEMW, 0, (LPARAM)&item);
item_data = (LPTV_ITEMDATA)item.lParam;
if(!item_data)
goto cleanup;
if(item_data->pEnumIL)
IEnumIDList_Release(item_data->pEnumIL);
hr = IShellFolder_EnumObjects(cur, info->hwndTreeView, flags, &item_data->pEnumIL);
if(FAILED(hr))
goto cleanup;
/* Update treeview */
if(!(item.state&TVIS_EXPANDEDONCE)) {
item.mask = TVIF_STATE;
item.state = TVIS_EXPANDEDONCE;
item.stateMask = TVIS_EXPANDEDONCE;
SendMessageW(info->hwndTreeView, TVM_SETITEMW, 0, (LPARAM)&item);
}
hr = IShellFolder_ParseDisplayName(cur, NULL, NULL, name+len, NULL, &new_item, NULL);
if(FAILED(hr))
goto cleanup;
added = InsertTreeViewItem(info, cur, new_item, item_data->lpifq, NULL, parent);
IShellFolder_Release(cur);
SHFree(new_item);
SendMessageW(info->hwndTreeView, TVM_SORTCHILDREN, FALSE, (LPARAM)parent);
return BrsFolder_Rename(info, added);
cleanup:
return hr;
}
static void test_ShortcutFolder(void) {
LPSHELLFOLDER pDesktopFolder, pWineTestFolder;
IPersistFolder3 *pWineTestPersistFolder;
LPITEMIDLIST pidlWineTestFolder, pidlCurFolder;
HRESULT hr;
CLSID clsid;
const CLSID CLSID_WineTest =
{ 0x9b352ebf, 0x2765, 0x45c1, { 0xb4, 0xc6, 0x85, 0xcc, 0x7f, 0x7a, 0xbc, 0x64 } };
WCHAR wszWineTestFolder[] = {
':',':','{','9','B','3','5','2','E','B','F','-','2','7','6','5','-','4','5','C','1','-',
'B','4','C','6','-','8','5','C','C','7','F','7','A','B','C','6','4','}',0 };
/* First, we register all the necessary registry keys/values for our 'WineTest'
* shell object. */
register_keys(HKEY_CLASSES_ROOT, HKEY_CLASSES_ROOT_keys, 1);
hr = SHGetDesktopFolder(&pDesktopFolder);
ok (SUCCEEDED(hr), "SHGetDesktopFolder failed! hr = %08x\n", hr);
if (FAILED(hr)) goto cleanup;
/* Convert the wszWineTestFolder string to an ITEMIDLIST. */
hr = IShellFolder_ParseDisplayName(pDesktopFolder, NULL, NULL, wszWineTestFolder, NULL,
&pidlWineTestFolder, NULL);
todo_wine
{
ok (hr == HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER),
"Expected %08x, got %08x\n", HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), hr);
}
if (FAILED(hr)) {
IShellFolder_Release(pDesktopFolder);
goto cleanup;
}
/* FIXME: these tests are never run */
/* Bind to a WineTest folder object. There has to be some support for this in shdocvw.dll.
* This isn't implemented in wine yet.*/
hr = IShellFolder_BindToObject(pDesktopFolder, pidlWineTestFolder, NULL, &IID_IShellFolder,
(LPVOID*)&pWineTestFolder);
IShellFolder_Release(pDesktopFolder);
ILFree(pidlWineTestFolder);
ok (SUCCEEDED(hr), "IShellFolder::BindToObject(WineTestFolder) failed! hr = %08x\n", hr);
if (FAILED(hr)) goto cleanup;
hr = IShellFolder_QueryInterface(pWineTestFolder, &IID_IPersistFolder3, (LPVOID*)&pWineTestPersistFolder);
ok (SUCCEEDED(hr), "IShellFolder::QueryInterface(IPersistFolder3) failed! hr = %08x\n", hr);
IShellFolder_Release(pWineTestFolder);
if (FAILED(hr)) goto cleanup;
/* The resulting folder object has the FolderShortcut CLSID, instead of it's own. */
hr = IPersistFolder3_GetClassID(pWineTestPersistFolder, &clsid);
ok (SUCCEEDED(hr), "IPersist::GetClassID failed! hr = %08x\n", hr);
ok (IsEqualCLSID(&CLSID_FolderShortcut, &clsid), "GetClassId returned wrong CLSID!\n");
pidlCurFolder = (LPITEMIDLIST)0xdeadbeef;
hr = IPersistFolder3_GetCurFolder(pWineTestPersistFolder, &pidlCurFolder);
ok (SUCCEEDED(hr), "IPersistFolder3::GetCurFolder failed! hr = %08x\n", hr);
ok (pidlCurFolder->mkid.cb == 20 && ((LPSHITEMID)((BYTE*)pidlCurFolder+20))->cb == 0 &&
IsEqualCLSID(&CLSID_WineTest, (REFCLSID)((LPBYTE)pidlCurFolder+4)),
"GetCurFolder returned unexpected pidl!\n");
ILFree(pidlCurFolder);
IPersistFolder3_Release(pWineTestPersistFolder);
cleanup:
unregister_keys(HKEY_CLASSES_ROOT, HKEY_CLASSES_ROOT_keys, 1);
}
/***********************************************************************
* SHELL32_BindToChild [Internal]
*
* Common code for IShellFolder_BindToObject.
*
* PARAMS
* pidlRoot [I] The parent shell folder's absolute pidl.
* pathRoot [I] Absolute dos path of the parent shell folder.
* pidlComplete [I] PIDL of the child. Relative to pidlRoot.
* riid [I] GUID of the interface, which ppvOut shall be bound to.
* ppvOut [O] A reference to the child's interface (riid).
*
* NOTES
* pidlComplete has to contain at least one non empty SHITEMID.
* This function makes special assumptions on the shell namespace, which
* means you probably can't use it for your IShellFolder implementation.
*/
HRESULT SHELL32_BindToChild (LPCITEMIDLIST pidlRoot,
LPCWSTR pathRoot, LPCITEMIDLIST pidlComplete, REFIID riid, LPVOID * ppvOut)
{
GUID const *clsid;
IShellFolder *pSF;
HRESULT hr;
LPITEMIDLIST pidlChild;
TRACE("(%p %s %p %s %p)\n", pidlRoot, debugstr_w(pathRoot), pidlComplete, debugstr_guid(riid), ppvOut);
if (!pidlRoot || !ppvOut || _ILIsEmpty(pidlComplete))
return E_INVALIDARG;
*ppvOut = NULL;
pidlChild = ILCloneFirst (pidlComplete);
if ((clsid = _ILGetGUIDPointer (pidlChild))) {
/* virtual folder */
hr = SHELL32_CoCreateInitSF (pidlRoot, pathRoot, pidlChild, clsid, (LPVOID *)&pSF);
} else if (_ILIsValue(pidlChild)) {
/* Don't bind to files */
hr = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
} else {
/* file system folder */
CLSID clsidFolder = CLSID_ShellFSFolder;
static const WCHAR wszCLSID[] = {'C','L','S','I','D',0};
WCHAR wszCLSIDValue[CHARS_IN_GUID], wszFolderPath[MAX_PATH], *pwszPathTail = wszFolderPath;
/* see if folder CLSID should be overridden by desktop.ini file */
if (pathRoot) {
lstrcpynW(wszFolderPath, pathRoot, MAX_PATH);
pwszPathTail = PathAddBackslashW(wszFolderPath);
}
_ILSimpleGetTextW(pidlChild,pwszPathTail,MAX_PATH - (int)(pwszPathTail - wszFolderPath));
if (SHELL32_GetCustomFolderAttributeFromPath (wszFolderPath,
wszDotShellClassInfo, wszCLSID, wszCLSIDValue, CHARS_IN_GUID))
CLSIDFromString (wszCLSIDValue, &clsidFolder);
hr = SHELL32_CoCreateInitSF (pidlRoot, pathRoot, pidlChild,
&clsidFolder, (LPVOID *)&pSF);
}
ILFree (pidlChild);
if (SUCCEEDED (hr)) {
if (_ILIsPidlSimple (pidlComplete)) {
/* no sub folders */
hr = IShellFolder_QueryInterface (pSF, riid, ppvOut);
} else {
/* go deeper */
hr = IShellFolder_BindToObject (pSF, ILGetNext (pidlComplete), NULL, riid, ppvOut);
}
IShellFolder_Release (pSF);
}
TRACE ("-- returning (%p) 0x%08x\n", *ppvOut, hr);
return hr;
}
/**************************************************************************
* DoCopyOrCut
*
* copies the currently selected items into the clipboard
*/
static BOOL DoCopyOrCut(
IContextMenu *iface,
HWND hwnd,
BOOL bCut)
{
ICOM_THIS(ItemCmImpl, iface);
LPSHELLBROWSER lpSB;
LPSHELLVIEW lpSV;
LPDATAOBJECT lpDo;
TRACE("(%p)->(wnd=0x%04x,bCut=0x%08x)\n",This, hwnd, bCut);
if(GetShellOle())
{
/* get the active IShellView */
if ((lpSB = (LPSHELLBROWSER)SendMessageA(hwnd, CWM_GETISHELLBROWSER,0,0)))
{
if (SUCCEEDED(IShellBrowser_QueryActiveShellView(lpSB, &lpSV)))
{
if (SUCCEEDED(IShellView_GetItemObject(lpSV, SVGIO_SELECTION, &IID_IDataObject, (LPVOID*)&lpDo)))
{
pOleSetClipboard(lpDo);
IDataObject_Release(lpDo);
}
IShellView_Release(lpSV);
}
}
}
return TRUE;
#if 0
/*
the following code does the copy operation witout ole32.dll
we might need this possibility too (js)
*/
BOOL bSuccess = FALSE;
TRACE("(%p)\n", iface);
if(OpenClipboard(NULL))
{
if(EmptyClipboard())
{
IPersistFolder2 * ppf2;
IShellFolder_QueryInterface(This->pSFParent, &IID_IPersistFolder2, (LPVOID*)&ppf2);
if (ppf2)
{
LPITEMIDLIST pidl;
IPersistFolder2_GetCurFolder(ppf2, &pidl);
if(pidl)
{
HGLOBAL hMem;
hMem = RenderHDROP(pidl, This->apidl, This->cidl);
if(SetClipboardData(CF_HDROP, hMem))
{
bSuccess = TRUE;
}
SHFree(pidl);
}
IPersistFolder2_Release(ppf2);
}
}
CloseClipboard();
}
return bSuccess;
#endif
}
static void update_path_box(explorer_info *info)
{
COMBOBOXEXITEMW item;
COMBOBOXEXITEMW main_item;
IShellFolder *desktop;
IPersistFolder2 *persist;
LPITEMIDLIST desktop_pidl;
IEnumIDList *ids;
ImageList_Remove((HIMAGELIST)info->icon_list,-1);
SendMessageW(info->path_box,CB_RESETCONTENT,0,0);
SHGetDesktopFolder(&desktop);
IShellFolder_QueryInterface(desktop,&IID_IPersistFolder2,(void**)&persist);
IPersistFolder2_GetCurFolder(persist,&desktop_pidl);
IPersistFolder2_Release(persist);
persist = NULL;
/*Add Desktop*/
item.iItem = -1;
item.mask = CBEIF_TEXT | CBEIF_INDENT | CBEIF_LPARAM;
item.iIndent = 0;
create_combobox_item(desktop,desktop_pidl,info->icon_list,&item);
item.lParam = (LPARAM)desktop_pidl;
SendMessageW(info->path_box,CBEM_INSERTITEMW,0,(LPARAM)&item);
if(ILIsEqual(info->pidl,desktop_pidl))
main_item = item;
else
CoTaskMemFree(item.pszText);
/*Add all direct subfolders of Desktop*/
if(SUCCEEDED(IShellFolder_EnumObjects(desktop,NULL,SHCONTF_FOLDERS,&ids))
&& ids!=NULL)
{
LPITEMIDLIST curr_pidl=NULL;
HRESULT hres;
item.iIndent = 1;
while(1)
{
ILFree(curr_pidl);
curr_pidl=NULL;
hres = IEnumIDList_Next(ids,1,&curr_pidl,NULL);
if(FAILED(hres) || hres == S_FALSE)
break;
if(!create_combobox_item(desktop,curr_pidl,info->icon_list,&item))
WINE_WARN("Could not create a combobox item\n");
else
{
LPITEMIDLIST full_pidl = ILCombine(desktop_pidl,curr_pidl);
item.lParam = (LPARAM)full_pidl;
SendMessageW(info->path_box,CBEM_INSERTITEMW,0,(LPARAM)&item);
if(ILIsEqual(full_pidl,info->pidl))
main_item = item;
else if(ILIsParent(full_pidl,info->pidl,FALSE))
{
/*add all parents of the pidl passed in*/
LPITEMIDLIST next_pidl = ILFindChild(full_pidl,info->pidl);
IShellFolder *curr_folder = NULL, *temp;
hres = IShellFolder_BindToObject(desktop,curr_pidl,NULL,
&IID_IShellFolder,
(void**)&curr_folder);
if(FAILED(hres))
WINE_WARN("Could not get an IShellFolder\n");
while(!ILIsEmpty(next_pidl))
{
LPITEMIDLIST first = ILCloneFirst(next_pidl);
CoTaskMemFree(item.pszText);
if(!create_combobox_item(curr_folder,first,
info->icon_list,&item))
{
WINE_WARN("Could not create a combobox item\n");
break;
}
++item.iIndent;
full_pidl = ILCombine(full_pidl,first);
item.lParam = (LPARAM)full_pidl;
SendMessageW(info->path_box,CBEM_INSERTITEMW,0,(LPARAM)&item);
temp=NULL;
hres = IShellFolder_BindToObject(curr_folder,first,NULL,
&IID_IShellFolder,
(void**)&temp);
if(FAILED(hres))
{
WINE_WARN("Could not get an IShellFolder\n");
break;
}
IShellFolder_Release(curr_folder);
curr_folder = temp;
ILFree(first);
next_pidl = ILGetNext(next_pidl);
}
memcpy(&main_item,&item,sizeof(item));
if(curr_folder)
IShellFolder_Release(curr_folder);
item.iIndent = 1;
}
else
CoTaskMemFree(item.pszText);
}
}
ILFree(curr_pidl);
IEnumIDList_Release(ids);
}
else
WINE_WARN("Could not enumerate the desktop\n");
SendMessageW(info->path_box,CBEM_SETITEMW,0,(LPARAM)&main_item);
CoTaskMemFree(main_item.pszText);
}
