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);
*psfgaoAttribs &= sfgaoMask;
IShellFolder_Release(parent_folder);
if (SUCCEEDED(ret))
{
if(sfgaoMask == *psfgaoAttribs)
return S_OK;
else
return S_FALSE;
}
}
return ret;
}
static void DoRestore(RecycleBinMenu *This)
{
/*TODO add prompts*/
UINT i;
for(i=0;i<This->cidl;i++)
{
WIN32_FIND_DATAW data;
TRASH_UnpackItemID(&((This->apidl[i])->mkid),&data);
if(PathFileExistsW(data.cFileName))
{
PIDLIST_ABSOLUTE dest_pidl = ILCreateFromPathW(data.cFileName);
WCHAR message[100];
WCHAR caption[50];
if(_ILIsFolder(ILFindLastID(dest_pidl)))
LoadStringW(shell32_hInstance,IDS_RECYCLEBIN_OVERWRITEFOLDER,
message,sizeof(message)/sizeof(WCHAR));
else
LoadStringW(shell32_hInstance,IDS_RECYCLEBIN_OVERWRITEFILE,
message,sizeof(message)/sizeof(WCHAR));
LoadStringW(shell32_hInstance,IDS_RECYCLEBIN_OVERWRITE_CAPTION,
caption,sizeof(caption)/sizeof(WCHAR));
if(ShellMessageBoxW(shell32_hInstance,GetActiveWindow(),message,
caption,MB_YESNO|MB_ICONEXCLAMATION,
data.cFileName)!=IDYES)
continue;
}
if(SUCCEEDED(TRASH_RestoreItem(This->apidl[i])))
{
IPersistFolder2 *persist;
LPITEMIDLIST root_pidl;
PIDLIST_ABSOLUTE dest_pidl = ILCreateFromPathW(data.cFileName);
BOOL is_folder = _ILIsFolder(ILFindLastID(dest_pidl));
IShellFolder2_QueryInterface(This->folder,&IID_IPersistFolder2,
(void**)&persist);
IPersistFolder2_GetCurFolder(persist,&root_pidl);
SHChangeNotify(is_folder ? SHCNE_RMDIR : SHCNE_DELETE,
SHCNF_IDLIST,ILCombine(root_pidl,This->apidl[i]),0);
SHChangeNotify(is_folder ? SHCNE_MKDIR : SHCNE_CREATE,
SHCNF_IDLIST,dest_pidl,0);
ILFree(dest_pidl);
ILFree(root_pidl);
}
}
}
/// <summary>
/// Handles change notifications for the current folder.
/// </summary>
LRESULT TileGroup::HandleChangeNotify(HANDLE changeHandle, DWORD processId) {
long event;
PIDLIST_ABSOLUTE *idList;
HANDLE notifyLock = SHChangeNotification_Lock(changeHandle, processId, &idList, &event);
if (notifyLock) {
switch (event) {
case SHCNE_ATTRIBUTES:
case SHCNE_UPDATEITEM:
case SHCNE_UPDATEDIR:
UpdateIcon(ILFindLastID(idList[0]));
break;
case SHCNE_MKDIR:
case SHCNE_CREATE:
AddIcon(ILFindLastID(idList[0]));
break;
case SHCNE_RMDIR:
case SHCNE_DELETE:
RemoveIcon(ILFindLastID(idList[0]));
break;
case SHCNE_RENAMEITEM:
case SHCNE_RENAMEFOLDER:
RenameIcon(ILFindLastID(idList[0]), ILFindLastID(idList[1]));
break;
case SHCNE_ASSOCCHANGED:
case SHCNE_UPDATEIMAGE:
UpdateAllIcons();
break;
}
SHChangeNotification_Unlock(notifyLock);
}
return 0;
}
/***********************************************************************
* SHELL32_BindToFS [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_BindToFS (LPCITEMIDLIST pidlRoot,
LPCWSTR pathRoot, LPCITEMIDLIST pidlComplete, REFIID riid, LPVOID * ppvOut)
{
CComPtr<IShellFolder> pSF;
HRESULT hr;
LPCITEMIDLIST pidlChild;
if (!pidlRoot || !ppvOut || !pidlComplete || !pidlComplete->mkid.cb)
return E_INVALIDARG;
if (_ILIsValue(pidlComplete))
{
ERR("Binding to file is unimplemented\n");
return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
}
if (!_ILIsFolder(pidlComplete) && !_ILIsDrive(pidlComplete))
{
ERR("Got an unknown type of pidl!\n");
return E_FAIL;
}
*ppvOut = NULL;
pidlChild = (_ILIsPidlSimple (pidlComplete)) ? pidlComplete : ILCloneFirst (pidlComplete);
CLSID clsidFolder = CLSID_ShellFSFolder;
DWORD attributes = _ILGetFileAttributes(ILFindLastID(pidlChild), NULL, 0);
if ((attributes & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)) != 0)
SHELL32_GetCLSIDForDirectory(pathRoot, pidlChild, &clsidFolder);
hr = SHELL32_CoCreateInitSF (pidlRoot, pathRoot, pidlChild, clsidFolder, &pSF);
if (pidlChild != pidlComplete)
ILFree ((LPITEMIDLIST)pidlChild);
if (SUCCEEDED (hr)) {
if (_ILIsPidlSimple (pidlComplete)) {
/* no sub folders */
hr = pSF->QueryInterface(riid, ppvOut);
} else {
/* go deeper */
hr = pSF->BindToObject(ILGetNext (pidlComplete), NULL, riid, ppvOut);
}
}
TRACE ("-- returning (%p) %08x\n", *ppvOut, hr);
return hr;
}
static HRESULT WINAPI IShellExecuteHookW_fnExecute(IShellExecuteHookW *iface,
LPSHELLEXECUTEINFOW psei)
{
ICPanelImpl *This = impl_from_IShellExecuteHookW(iface);
static const WCHAR wCplopen[] = {'c','p','l','o','p','e','n','\0'};
SHELLEXECUTEINFOW sei_tmp;
PIDLCPanelStruct* pcpanel;
WCHAR path[MAX_PATH];
WCHAR params[MAX_PATH];
BOOL ret;
int l;
TRACE("(%p)->execute(%p)\n", This, psei);
if (!psei)
return E_INVALIDARG;
pcpanel = _ILGetCPanelPointer(ILFindLastID(psei->lpIDList));
if (!pcpanel)
return E_INVALIDARG;
path[0] = '\"';
/* Return value from MultiByteToWideChar includes terminating NUL, which
* compensates for the starting double quote we just put in */
l = MultiByteToWideChar(CP_ACP, 0, pcpanel->szName, -1, path+1, MAX_PATH-1);
/* pass applet name to Control_RunDLL to distinguish between applets in one .cpl file */
path[l++] = '"';
path[l] = '\0';
MultiByteToWideChar(CP_ACP, 0, pcpanel->szName+pcpanel->offsDispName, -1, params, MAX_PATH);
sei_tmp = *psei;
sei_tmp.lpFile = path;
sei_tmp.lpParameters = params;
sei_tmp.fMask &= ~SEE_MASK_INVOKEIDLIST;
sei_tmp.lpVerb = wCplopen;
ret = ShellExecuteExW(&sei_tmp);
if (ret)
return S_OK;
else
return S_FALSE;
}
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_NetConnect_ShellExecuteHookW_Execute
*/
HRESULT WINAPI CNetworkConnections::Execute(LPSHELLEXECUTEINFOW pei)
{
const VALUEStruct *val;
NETCON_PROPERTIES * pProperties;
val = _ILGetValueStruct(ILFindLastID((ITEMIDLIST*)pei->lpIDList));
if (!val)
return E_FAIL;
if (val->pItem->GetProperties(&pProperties) != NOERROR)
return E_FAIL;
if (pProperties->Status == NCS_CONNECTED)
{
NcFreeNetconProperties(pProperties);
return ShowNetConnectionStatus(m_lpOleCmd, val->pItem, pei->hwnd);
}
NcFreeNetconProperties(pProperties);
return S_OK;
}
static HRESULT WINAPI IShellExecuteHookA_fnExecute(IShellExecuteHookA *iface,
LPSHELLEXECUTEINFOA psei)
{
ICPanelImpl *This = impl_from_IShellExecuteHookA(iface);
SHELLEXECUTEINFOA sei_tmp;
PIDLCPanelStruct* pcpanel;
char path[MAX_PATH];
BOOL ret;
TRACE("(%p)->execute(%p)\n", This, psei);
if (!psei)
return E_INVALIDARG;
pcpanel = _ILGetCPanelPointer(ILFindLastID(psei->lpIDList));
if (!pcpanel)
return E_INVALIDARG;
path[0] = '\"';
lstrcpyA(path+1, pcpanel->szName);
/* pass applet name to Control_RunDLL to distinguish between applets in one .cpl file */
lstrcatA(path, "\" ");
lstrcatA(path, pcpanel->szName+pcpanel->offsDispName);
sei_tmp = *psei;
sei_tmp.lpFile = path;
sei_tmp.fMask &= ~SEE_MASK_INVOKEIDLIST;
ret = ShellExecuteExA(&sei_tmp);
if (ret)
return S_OK;
else
return S_FALSE;
}
HRESULT CNewMenu::SelectNewItem(LPCMINVOKECOMMANDINFO lpici, LONG wEventId, UINT uFlags, LPWSTR pszName)
{
CComPtr<IShellBrowser> lpSB;
CComPtr<IShellView> lpSV;
HRESULT hr = E_FAIL;
LPITEMIDLIST pidl;
PITEMID_CHILD pidlNewItem;
/* Notify the view object about the new item */
SHChangeNotify(wEventId, uFlags, (LPCVOID) pszName, NULL);
/* FIXME: I think that this can be implemented using callbacks to the shell folder */
/* Note: CWM_GETISHELLBROWSER returns shell browser without adding reference */
lpSB = (LPSHELLBROWSER)SendMessageA(lpici->hwnd, CWM_GETISHELLBROWSER, 0, 0);
if (!lpSB)
return E_FAIL;
hr = lpSB->QueryActiveShellView(&lpSV);
if (FAILED(hr))
return hr;
/* Attempt to get the pidl of the new item */
hr = SHILCreateFromPathW(pszName, &pidl, NULL);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
pidlNewItem = ILFindLastID(pidl);
hr = lpSV->SelectItem(pidlNewItem, SVSI_DESELECTOTHERS | SVSI_EDIT | SVSI_ENSUREVISIBLE |
SVSI_FOCUSED | SVSI_SELECT);
SHFree(pidl);
return hr;
}
/******************************************************************************
* InitializeTreeView [Internal]
*
* Called from WM_INITDIALOG handler.
*
* PARAMS
* hwndParent [I] The BrowseForFolder dialog
* root [I] ITEMIDLIST of the root shell folder
*/
static void InitializeTreeView( browse_info *info )
{
LPITEMIDLIST pidlParent, pidlChild;
HIMAGELIST hImageList;
HRESULT hr;
IShellFolder *lpsfParent, *lpsfRoot;
IEnumIDList * pEnumChildren = NULL;
HTREEITEM item;
DWORD flags;
LPCITEMIDLIST root = info->lpBrowseInfo->pidlRoot;
TRACE("%p\n", info );
Shell_GetImageLists(NULL, &hImageList);
if (hImageList)
SendMessageW( info->hwndTreeView, TVM_SETIMAGELIST, 0, (LPARAM)hImageList );
/* We want to call InsertTreeViewItem down the code, in order to insert
* the root item of the treeview. Due to InsertTreeViewItem's signature,
* we need the following to do this:
*
* + An ITEMIDLIST corresponding to _the parent_ of root.
* + An ITEMIDLIST, which is a relative path from root's parent to root
* (containing a single SHITEMID).
* + An IShellFolder interface pointer of root's parent folder.
*
* If root is 'Desktop', then root's parent is also 'Desktop'.
*/
pidlParent = ILClone(root);
ILRemoveLastID(pidlParent);
pidlChild = ILClone(ILFindLastID(root));
if (_ILIsDesktop(pidlParent)) {
hr = SHGetDesktopFolder(&lpsfParent);
} else {
IShellFolder *lpsfDesktop;
hr = SHGetDesktopFolder(&lpsfDesktop);
if (!SUCCEEDED(hr)) {
WARN("SHGetDesktopFolder failed! hr = %08x\n", hr);
return;
}
hr = IShellFolder_BindToObject(lpsfDesktop, pidlParent, 0, &IID_IShellFolder, (LPVOID*)&lpsfParent);
IShellFolder_Release(lpsfDesktop);
}
if (!SUCCEEDED(hr)) {
WARN("Could not bind to parent shell folder! hr = %08x\n", hr);
return;
}
if (pidlChild && pidlChild->mkid.cb) {
hr = IShellFolder_BindToObject(lpsfParent, pidlChild, 0, &IID_IShellFolder, (LPVOID*)&lpsfRoot);
} else {
lpsfRoot = lpsfParent;
hr = IShellFolder_AddRef(lpsfParent);
}
if (!SUCCEEDED(hr)) {
WARN("Could not bind to root shell folder! hr = %08x\n", hr);
IShellFolder_Release(lpsfParent);
return;
}
flags = BrowseFlagsToSHCONTF( info->lpBrowseInfo->ulFlags );
hr = IShellFolder_EnumObjects( lpsfRoot, info->hWnd, flags, &pEnumChildren );
if (!SUCCEEDED(hr)) {
WARN("Could not get child iterator! hr = %08x\n", hr);
IShellFolder_Release(lpsfParent);
IShellFolder_Release(lpsfRoot);
return;
}
SendMessageW( info->hwndTreeView, TVM_DELETEITEM, 0, (LPARAM)TVI_ROOT );
item = InsertTreeViewItem( info, lpsfParent, pidlChild,
pidlParent, pEnumChildren, TVI_ROOT );
SendMessageW( info->hwndTreeView, TVM_EXPAND, TVE_EXPAND, (LPARAM)item );
IShellFolder_Release(lpsfRoot);
IShellFolder_Release(lpsfParent);
}
/**************************************************************************
* IExtractIconW_Constructor
*/
IExtractIconW* IExtractIconW_Constructor(LPCITEMIDLIST pidl)
{
CComPtr<IDefaultExtractIconInit> initIcon;
IExtractIconW *extractIcon;
GUID const * riid;
int icon_idx;
UINT flags;
CHAR sTemp[MAX_PATH];
WCHAR wTemp[MAX_PATH];
LPITEMIDLIST pSimplePidl = ILFindLastID(pidl);
HRESULT hr;
hr = SHCreateDefaultExtractIcon(IID_PPV_ARG(IDefaultExtractIconInit,&initIcon));
if (FAILED(hr))
return NULL;
hr = initIcon->QueryInterface(IID_PPV_ARG(IExtractIconW,&extractIcon));
if (FAILED(hr))
return NULL;
if (_ILIsDesktop(pSimplePidl))
{
initIcon->SetNormalIcon(swShell32Name, -IDI_SHELL_DESKTOP);
}
else if ((riid = _ILGetGUIDPointer(pSimplePidl)))
{
/* my computer and other shell extensions */
static const WCHAR fmt[] = { 'C', 'L', 'S', 'I', 'D', '\\',
'{', '%', '0', '8', 'l', 'x', '-', '%', '0', '4', 'x', '-', '%', '0', '4', 'x', '-',
'%', '0', '2', 'x', '%', '0', '2', 'x', '-', '%', '0', '2', 'x', '%', '0', '2', 'x',
'%', '0', '2', 'x', '%', '0', '2', 'x', '%', '0', '2', 'x', '%', '0', '2', 'x', '}', 0
};
WCHAR xriid[50];
swprintf(xriid, fmt,
riid->Data1, riid->Data2, riid->Data3,
riid->Data4[0], riid->Data4[1], riid->Data4[2], riid->Data4[3],
riid->Data4[4], riid->Data4[5], riid->Data4[6], riid->Data4[7]);
const WCHAR* iconname = NULL;
if (_ILIsBitBucket(pSimplePidl))
{
static const WCHAR szFull[] = {'F','u','l','l',0};
static const WCHAR szEmpty[] = {'E','m','p','t','y',0};
IEnumIDList *EnumIDList = NULL;
CoInitialize(NULL);
IShellFolder2 *psfRecycleBin = NULL;
IShellFolder *psfDesktop = NULL;
hr = SHGetDesktopFolder(&psfDesktop);
if (SUCCEEDED(hr))
hr = psfDesktop->BindToObject(pSimplePidl, NULL, IID_IShellFolder2, (void**) &psfRecycleBin);
if (SUCCEEDED(hr))
hr = psfRecycleBin->EnumObjects(NULL, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS, &EnumIDList);
ULONG itemcount;
LPITEMIDLIST pidl = NULL;
if (SUCCEEDED(hr) && (hr = EnumIDList->Next(1, &pidl, &itemcount)) == S_OK)
{
CoTaskMemFree(pidl);
iconname = szFull;
} else {
iconname = szEmpty;
}
if (psfDesktop)
psfDesktop->Release();
if (psfRecycleBin)
psfRecycleBin->Release();
if (EnumIDList)
EnumIDList->Release();
}
if (HCR_GetIconW(xriid, wTemp, iconname, MAX_PATH, &icon_idx))
{
initIcon->SetNormalIcon(wTemp, icon_idx);
}
else
{
if (IsEqualGUID(*riid, CLSID_MyComputer))
initIcon->SetNormalIcon(swShell32Name, -IDI_SHELL_MY_COMPUTER);
else if (IsEqualGUID(*riid, CLSID_MyDocuments))
initIcon->SetNormalIcon(swShell32Name, -IDI_SHELL_MY_DOCUMENTS);
else if (IsEqualGUID(*riid, CLSID_NetworkPlaces))
initIcon->SetNormalIcon(swShell32Name, -IDI_SHELL_MY_NETWORK_PLACES);
else
initIcon->SetNormalIcon(swShell32Name, -IDI_SHELL_FOLDER);
}
}
else if (_ILIsDrive (pSimplePidl))
{
static const WCHAR drive[] = { 'D', 'r', 'i', 'v', 'e', 0 };
int icon_idx = -1;
if (_ILGetDrive(pSimplePidl, sTemp, MAX_PATH))
{
switch(GetDriveTypeA(sTemp))
{
case DRIVE_REMOVABLE:
icon_idx = IDI_SHELL_FLOPPY;
break;
case DRIVE_CDROM:
icon_idx = IDI_SHELL_CDROM;
break;
case DRIVE_REMOTE:
icon_idx = IDI_SHELL_NETDRIVE;
break;
case DRIVE_RAMDISK:
icon_idx = IDI_SHELL_RAMDISK;
break;
case DRIVE_NO_ROOT_DIR:
icon_idx = IDI_SHELL_CDROM;
break;
}
}
if (icon_idx != -1)
{
initIcon->SetNormalIcon(swShell32Name, -icon_idx);
}
else
{
if (HCR_GetIconW(drive, wTemp, NULL, MAX_PATH, &icon_idx))
initIcon->SetNormalIcon(wTemp, icon_idx);
else
initIcon->SetNormalIcon(swShell32Name, -IDI_SHELL_DRIVE);
}
}
else if (_ILIsFolder (pSimplePidl))
{
if (SUCCEEDED(getIconLocationForFolder(
pidl, 0, wTemp, MAX_PATH,
&icon_idx,
&flags)))
{
initIcon->SetNormalIcon(wTemp, icon_idx);
// FIXME: if/when getIconLocationForFolder does something for
// GIL_FORSHORTCUT, code below should be uncommented. and
// the following line removed.
initIcon->SetShortcutIcon(wTemp, icon_idx);
}
if (SUCCEEDED(getIconLocationForFolder(
pidl, GIL_DEFAULTICON, wTemp, MAX_PATH,
&icon_idx,
&flags)))
{
initIcon->SetDefaultIcon(wTemp, icon_idx);
}
// if (SUCCEEDED(getIconLocationForFolder(
// pidl, GIL_FORSHORTCUT, wTemp, MAX_PATH,
// &icon_idx,
// &flags)))
// {
// initIcon->SetShortcutIcon(wTemp, icon_idx);
// }
if (SUCCEEDED(getIconLocationForFolder(
pidl, GIL_OPENICON, wTemp, MAX_PATH,
&icon_idx,
&flags)))
{
initIcon->SetOpenIcon(wTemp, icon_idx);
}
}
else
{
BOOL found = FALSE;
if (_ILIsCPanelStruct(pSimplePidl))
{
if (SUCCEEDED(CPanel_GetIconLocationW(pSimplePidl, wTemp, MAX_PATH, &icon_idx)))
found = TRUE;
}
else if (_ILGetExtension(pSimplePidl, sTemp, MAX_PATH))
{
if (HCR_MapTypeToValueA(sTemp, sTemp, MAX_PATH, TRUE)
&& HCR_GetIconA(sTemp, sTemp, NULL, MAX_PATH, &icon_idx))
{
if (!lstrcmpA("%1", sTemp)) /* icon is in the file */
{
SHGetPathFromIDListW(pidl, wTemp);
icon_idx = 0;
}
else
{
MultiByteToWideChar(CP_ACP, 0, sTemp, -1, wTemp, MAX_PATH);
}
found = TRUE;
}
else if (!lstrcmpiA(sTemp, "lnkfile"))
{
/* extract icon from shell shortcut */
CComPtr<IShellFolder> dsf;
CComPtr<IShellLinkW> psl;
if (SUCCEEDED(SHGetDesktopFolder(&dsf)))
{
HRESULT hr = dsf->GetUIObjectOf(NULL, 1, (LPCITEMIDLIST*)&pidl, IID_IShellLinkW, NULL, (LPVOID *)&psl);
if (SUCCEEDED(hr))
{
hr = psl->GetIconLocation(wTemp, MAX_PATH, &icon_idx);
if (SUCCEEDED(hr) && *sTemp)
found = TRUE;
}
}
}
}
if (!found)
/* default icon */
initIcon->SetNormalIcon(swShell32Name, 0);
else
initIcon->SetNormalIcon(wTemp, icon_idx);
}
return extractIcon;
}
HRESULT AddContextMenu(WCHAR* file)
{
HRESULT hr = E_UNEXPECTED;
LPVOID lpVoid;
HMENU fileMenu = CreatePopupMenu();
IShellFolder* deskFolder = NULL;
IShellFolder* appObject = NULL;
LPITEMIDLIST pidlLocal = NULL;
LPITEMIDLIST pidlRelative = NULL;
IContextMenu* contextMenu = NULL;
CONTEXTINFO contextInfo;
wcscpy(contextInfo.value, file);
hr = SHGetDesktopFolder(&deskFolder);
if (FAILED(hr))
{
return hr;
}
hr = deskFolder->ParseDisplayName(NULL, NULL, file, NULL, &pidlLocal, NULL);
if (FAILED(hr))
{
deskFolder->Release();
return hr;
}
pidlRelative = ILClone(ILFindLastID(pidlLocal));
ILRemoveLastID(pidlLocal);
hr = deskFolder->BindToObject(pidlLocal, NULL, IID_IShellFolder, &lpVoid);
if (FAILED(hr))
{
deskFolder->Release();
ILFree(pidlLocal);
return hr;
}
appObject = reinterpret_cast <IShellFolder*> (lpVoid);
deskFolder->Release();
ILFree(pidlLocal);
hr = appObject->GetUIObjectOf(NULL, 1, (LPCITEMIDLIST*)&pidlRelative,
IID_IContextMenu, NULL, &lpVoid);
if (FAILED(hr))
{
appObject->Release();
ILFree(pidlRelative);
return hr;
}
contextMenu = reinterpret_cast <IContextMenu*> (lpVoid);
ILFree(pidlRelative);
appObject->Release();
contextMenu->QueryInterface(IID_IContextMenu2, &lpVoid);
if (FAILED(hr))
{
contextMenu->Release();
return hr;
}
contextInfo.ic2 = reinterpret_cast <IContextMenu2*> (lpVoid);
contextMenu->Release();
hr = contextInfo.ic2->QueryContextMenu(fileMenu, 0, SYSMENUMIN, SYSMENUMAX, CMF_NORMAL);
if (FAILED(hr))
{
contextInfo.ic2->Release();
return hr;
}
if (!ELIsDirectory(file))
{
AppendMenu(fileMenu, MF_SEPARATOR, 0x8000, NULL);
AppendMenu(fileMenu, MF_STRING, 0x8001, TEXT("Open Folder"));
}
contextMap.insert(std::pair<HMENU, CONTEXTINFO>(fileMenu, contextInfo));
return hr;
}
Path::iterator Path::end () const
{
return (iterator(ILNext(ILFindLastID(myBackend))));
}
void CDisplayWindow::ExtractThumbnailImageInternal(ThumbnailEntry_t *pte)
{
IExtractImage *pExtractImage = NULL;
IShellFolder *pShellFolder = NULL;
LPITEMIDLIST pidlParent = NULL;
LPITEMIDLIST pidlFull = NULL;
LPITEMIDLIST pridl = NULL;
HBITMAP hBitmap;
BITMAP bm;
RECT rc;
SIZE size;
TCHAR szImage[MAX_PATH];
DWORD dwPriority;
DWORD dwFlags;
HRESULT hr;
m_bThumbnailExtracted = TRUE;
m_bThumbnailExtractionFailed = TRUE;
hr = GetIdlFromParsingName(m_ImageFile,&pidlFull);
if(SUCCEEDED(hr))
{
pidlParent = ILClone(pidlFull);
ILRemoveLastID(pidlParent);
pridl = ILClone(ILFindLastID(pidlFull));
hr = BindToIdl(pidlParent, IID_PPV_ARGS(&pShellFolder));
if(SUCCEEDED(hr))
{
hr = GetUIObjectOf(pShellFolder, NULL, 1, (LPCITEMIDLIST *) &pridl,
IID_PPV_ARGS(&pExtractImage));
if(SUCCEEDED(hr))
{
GetClientRect(m_hDisplayWindow,&rc);
/* First, query the thumbnail so that its actual aspect
ratio can be calculated. */
dwFlags = IEIFLAG_OFFLINE|IEIFLAG_QUALITY|IEIFLAG_ORIGSIZE;
size.cx = GetRectHeight(&rc) - THUMB_HEIGHT_DELTA;
size.cy = GetRectHeight(&rc) - THUMB_HEIGHT_DELTA;
hr = pExtractImage->GetLocation(szImage,SIZEOF_ARRAY(szImage),
&dwPriority,&size,32,&dwFlags);
if(SUCCEEDED(hr))
{
hr = pExtractImage->Extract(&hBitmap);
if(SUCCEEDED(hr))
{
/* Get bitmap information (including height and width). */
GetObject(hBitmap,sizeof(BITMAP),&bm);
/* Delete the original bitmap. */
DeleteObject(hBitmap);
/* ...now query the thumbnail again, this time adjusting
the width of the suggested area based on the actual aspect
ratio. */
dwFlags = IEIFLAG_OFFLINE|IEIFLAG_QUALITY|IEIFLAG_ASPECT|IEIFLAG_ORIGSIZE;
size.cy = GetRectHeight(&rc) - THUMB_HEIGHT_DELTA;
size.cx = (LONG)((double)size.cy * ((double)bm.bmWidth / (double)bm.bmHeight));
m_iImageWidth = size.cx;
m_iImageHeight = size.cy;
pExtractImage->GetLocation(szImage,SIZEOF_ARRAY(szImage),
&dwPriority,&size,32,&dwFlags);
hr = pExtractImage->Extract(&m_hbmThumbnail);
if(SUCCEEDED(hr))
{
/* Check first if we've been cancelled. This might happen,
for example, if another file is selected while the current
thumbnail is been found. */
EnterCriticalSection(&m_csDWThumbnails);
if(!pte->bCancelled)
{
m_bThumbnailExtractionFailed = FALSE;
InvalidateRect(m_hDisplayWindow,NULL,FALSE);
}
LeaveCriticalSection(&m_csDWThumbnails);
}
else
{
m_bThumbnailExtractionFailed = TRUE;
m_hbmThumbnail = NULL;
}
}
}
pExtractImage->Release();
}
pShellFolder->Release();
}
CoTaskMemFree(pidlFull);
CoTaskMemFree(pidlParent);
CoTaskMemFree(pridl);
}
}
/**************************************************************************
* ICPanel_IContextMenu_InvokeCommand()
*/
HRESULT WINAPI CControlPanelFolder::InvokeCommand(LPCMINVOKECOMMANDINFO lpcmi)
{
WCHAR szPath[MAX_PATH];
char szTarget[MAX_PATH];
STRRET strret;
WCHAR* pszPath;
INT Length, cLength;
CComPtr<IPersistFile> ppf;
CComPtr<IShellLinkA> isl;
HRESULT hResult;
PIDLCPanelStruct *pcpanel = _ILGetCPanelPointer(apidl[0]);
TRACE("(%p)->(invcom=%p verb=%p wnd=%p)\n", this, lpcmi, lpcmi->lpVerb, lpcmi->hwnd);
if (lpcmi->lpVerb == MAKEINTRESOURCEA(IDS_OPEN)) //FIXME
{
LPITEMIDLIST lpIDList = ILCombine(pidlRoot, apidl[0]);
if (!pcpanel)
{
/* UGLY HACK! */
LPSHELLBROWSER lpSB = (LPSHELLBROWSER)SendMessageW(lpcmi->hwnd, CWM_GETISHELLBROWSER, 0, 0);
HRESULT hr;
if (lpSB == NULL)
return E_FAIL;
hr = lpSB->BrowseObject(lpIDList, 0);
return hr;
}
/* Note: we pass the applet name to Control_RunDLL to distinguish between multiple applets in one .cpl file */
ShellExecuteA(NULL, "cplopen", pcpanel->szName, pcpanel->szName + pcpanel->offsDispName, NULL, 0);
}
else if (lpcmi->lpVerb == MAKEINTRESOURCEA(IDS_CREATELINK)) //FIXME
{
if (!SHGetSpecialFolderPathW(NULL, szPath, CSIDL_DESKTOPDIRECTORY, FALSE))
return E_FAIL;
pszPath = PathAddBackslashW(szPath);
if (!pszPath)
return E_FAIL;
if (GetDisplayNameOf(apidl[0], SHGDN_FORPARSING, &strret) != S_OK)
return E_FAIL;
Length = MAX_PATH - (pszPath - szPath);
cLength = strlen(strret.cStr);
if (Length < cLength + 5)
{
FIXME("\n");
return E_FAIL;
}
if (MultiByteToWideChar(CP_ACP, 0, strret.cStr, cLength + 1, pszPath, Length))
{
pszPath += cLength;
Length -= cLength;
}
if (Length > 10)
{
wcscpy(pszPath, L" - ");
cLength = LoadStringW(shell32_hInstance, IDS_LNK_FILE, &pszPath[3], Length - 4) + 3;
if (cLength + 5 > Length)
cLength = Length - 5;
Length -= cLength;
pszPath += cLength;
}
wcscpy(pszPath, L".lnk");
pcpanel = _ILGetCPanelPointer(ILFindLastID(apidl[0]));
if (pcpanel)
{
strncpy(szTarget, pcpanel->szName, MAX_PATH);
}
else
{
FIXME("Couldn't retrieve pointer to cpl structure\n");
return E_FAIL;
}
hResult = CShellLink::_CreatorClass::CreateInstance(NULL, IID_PPV_ARG(IShellLinkA, &isl));
if (SUCCEEDED(hResult))
{
isl->SetPath(szTarget);
if (SUCCEEDED(isl->QueryInterface(IID_PPV_ARG(IPersistFile,&ppf))))
ppf->Save(szPath, TRUE);
}
return NOERROR;
}
return S_OK;
}
/**************************************************************************
* IExtractIconW::GetIconLocation
*
* mapping filetype to icon
*/
static HRESULT WINAPI IExtractIconW_fnGetIconLocation(IExtractIconW * iface, UINT uFlags,
LPWSTR szIconFile, UINT cchMax, int * piIndex, UINT * pwFlags)
{
IExtractIconWImpl *This = impl_from_IExtractIconW(iface);
char sTemp[MAX_PATH];
int icon_idx;
GUID const * riid;
LPITEMIDLIST pSimplePidl = ILFindLastID(This->pidl);
TRACE("(%p) (flags=%u %p %u %p %p)\n", This, uFlags, szIconFile, cchMax, piIndex, pwFlags);
if (pwFlags)
*pwFlags = 0;
if (_ILIsDesktop(pSimplePidl))
{
lstrcpynW(szIconFile, swShell32Name, cchMax);
*piIndex = -IDI_SHELL_DESKTOP;
}
/* my computer and other shell extensions */
else if ((riid = _ILGetGUIDPointer(pSimplePidl)))
{
static const WCHAR fmt[] = { 'C','L','S','I','D','\\',
'{','%','0','8','l','x','-','%','0','4','x','-','%','0','4','x','-',
'%','0','2','x','%','0','2','x','-','%','0','2','x', '%','0','2','x',
'%','0','2','x','%','0','2','x','%','0','2','x','%','0','2','x','}',0 };
WCHAR xriid[50];
sprintfW(xriid, fmt,
riid->Data1, riid->Data2, riid->Data3,
riid->Data4[0], riid->Data4[1], riid->Data4[2], riid->Data4[3],
riid->Data4[4], riid->Data4[5], riid->Data4[6], riid->Data4[7]);
if (HCR_GetDefaultIconW(xriid, szIconFile, cchMax, &icon_idx))
{
*piIndex = icon_idx;
}
else
{
lstrcpynW(szIconFile, swShell32Name, cchMax);
if(IsEqualGUID(riid, &CLSID_MyComputer))
*piIndex = -IDI_SHELL_MY_COMPUTER;
else if(IsEqualGUID(riid, &CLSID_MyDocuments))
*piIndex = -IDI_SHELL_MY_DOCUMENTS;
else if(IsEqualGUID(riid, &CLSID_NetworkPlaces))
*piIndex = -IDI_SHELL_MY_NETWORK_PLACES;
else if(IsEqualGUID(riid, &CLSID_UnixFolder) ||
IsEqualGUID(riid, &CLSID_UnixDosFolder))
*piIndex = -IDI_SHELL_DRIVE;
else
*piIndex = -IDI_SHELL_FOLDER;
}
}
else if (_ILIsDrive (pSimplePidl))
{
static const WCHAR drive[] = { 'D','r','i','v','e',0 };
int icon_idx = -1;
if (_ILGetDrive(pSimplePidl, sTemp, MAX_PATH))
{
switch(GetDriveTypeA(sTemp))
{
case DRIVE_REMOVABLE: icon_idx = IDI_SHELL_FLOPPY; break;
case DRIVE_CDROM: icon_idx = IDI_SHELL_CDROM; break;
case DRIVE_REMOTE: icon_idx = IDI_SHELL_NETDRIVE; break;
case DRIVE_RAMDISK: icon_idx = IDI_SHELL_RAMDISK; break;
}
}
if (icon_idx != -1)
{
lstrcpynW(szIconFile, swShell32Name, cchMax);
*piIndex = -icon_idx;
}
else
{
if (HCR_GetDefaultIconW(drive, szIconFile, cchMax, &icon_idx))
{
*piIndex = icon_idx;
}
else
{
lstrcpynW(szIconFile, swShell32Name, cchMax);
*piIndex = -IDI_SHELL_DRIVE;
}
}
}
else if (_ILIsFolder (pSimplePidl))
{
getIconLocationForFolder(This, uFlags, szIconFile, cchMax, piIndex, pwFlags);
}
else
{
BOOL found = FALSE;
if (_ILIsCPanelStruct(pSimplePidl))
{
if (SUCCEEDED(CPanel_GetIconLocationW(pSimplePidl, szIconFile, cchMax, piIndex)))
found = TRUE;
}
else if (_ILGetExtension(pSimplePidl, sTemp, MAX_PATH))
{
if (HCR_MapTypeToValueA(sTemp, sTemp, MAX_PATH, TRUE)
&& HCR_GetDefaultIconA(sTemp, sTemp, MAX_PATH, &icon_idx))
{
if (!lstrcmpA("%1", sTemp)) /* icon is in the file */
{
SHGetPathFromIDListW(This->pidl, szIconFile);
*piIndex = 0;
}
else
{
MultiByteToWideChar(CP_ACP, 0, sTemp, -1, szIconFile, cchMax);
*piIndex = icon_idx;
}
found = TRUE;
}
else if (!lstrcmpiA(sTemp, "lnkfile"))
{
/* extract icon from shell shortcut */
IShellFolder* dsf;
IShellLinkW* psl;
if (SUCCEEDED(SHGetDesktopFolder(&dsf)))
{
HRESULT hr = IShellFolder_GetUIObjectOf(dsf, NULL, 1, (LPCITEMIDLIST*)&This->pidl, &IID_IShellLinkW, NULL, (LPVOID*)&psl);
if (SUCCEEDED(hr))
{
hr = IShellLinkW_GetIconLocation(psl, szIconFile, MAX_PATH, piIndex);
if (SUCCEEDED(hr) && *szIconFile)
found = TRUE;
IShellLinkW_Release(psl);
}
IShellFolder_Release(dsf);
}
}
}
if (!found) /* default icon */
{
lstrcpynW(szIconFile, swShell32Name, cchMax);
*piIndex = 0;
}
}
TRACE("-- %s %x\n", debugstr_w(szIconFile), *piIndex);
return S_OK;
}
/**************************************************************************
* ISF_Desktop_fnSetNameOf
* Changes the name of a file object or subfolder, possibly changing its item
* identifier in the process.
*
* PARAMETERS
* HWND hwndOwner, //[in ] Owner window for output
* LPCITEMIDLIST pidl, //[in ] simple pidl of item to change
* LPCOLESTR lpszName, //[in ] the items new display name
* DWORD dwFlags, //[in ] SHGNO formatting flags
* LPITEMIDLIST* ppidlOut) //[out] simple pidl returned
*/
static HRESULT WINAPI ISF_Desktop_fnSetNameOf (IShellFolder2 * iface,
HWND hwndOwner, LPCITEMIDLIST pidl, /* simple pidl */
LPCOLESTR lpName, DWORD dwFlags, LPITEMIDLIST * pPidlOut)
{
IGenericSFImpl *This = (IGenericSFImpl *)iface;
IShellFolder2 * psf;
HRESULT hr;
WCHAR szSrc[MAX_PATH + 1], szDest[MAX_PATH + 1];
LPWSTR ptr;
BOOL bIsFolder = _ILIsFolder (ILFindLastID (pidl));
TRACE ("(%p)->(%p,pidl=%p,%s,%u,%p)\n", This, hwndOwner, pidl,
debugstr_w (lpName), dwFlags, pPidlOut);
if (_ILGetGUIDPointer(pidl))
{
if (SUCCEEDED(IShellFolder2_BindToObject(iface, pidl, NULL, &IID_IShellFolder2, (LPVOID*)&psf)))
{
hr = IShellFolder2_SetNameOf(psf, hwndOwner, pidl, lpName, dwFlags, pPidlOut);
IShellFolder2_Release(psf);
return hr;
}
}
/* build source path */
lstrcpynW(szSrc, This->sPathTarget, MAX_PATH);
ptr = PathAddBackslashW (szSrc);
if (ptr)
_ILSimpleGetTextW (pidl, ptr, MAX_PATH + 1 - (ptr - szSrc));
/* build destination path */
if (dwFlags == SHGDN_NORMAL || dwFlags & SHGDN_INFOLDER) {
lstrcpynW(szDest, This->sPathTarget, MAX_PATH);
ptr = PathAddBackslashW (szDest);
if (ptr)
lstrcpynW(ptr, lpName, MAX_PATH + 1 - (ptr - szDest));
} else
lstrcpynW(szDest, lpName, MAX_PATH);
if(!(dwFlags & SHGDN_FORPARSING) && SHELL_FS_HideExtension(szSrc)) {
WCHAR *ext = PathFindExtensionW(szSrc);
if(*ext != '\0') {
INT len = wcslen(szDest);
lstrcpynW(szDest + len, ext, MAX_PATH - len);
}
}
if (!memcmp(szSrc, szDest, (wcslen(szDest)+1) * sizeof(WCHAR)))
{
/* src and destination is the same */
hr = S_OK;
if (pPidlOut)
hr = _ILCreateFromPathW(szDest, pPidlOut);
return hr;
}
TRACE ("src=%s dest=%s\n", debugstr_w(szSrc), debugstr_w(szDest));
if (MoveFileW (szSrc, szDest))
{
hr = S_OK;
if (pPidlOut)
hr = _ILCreateFromPathW(szDest, pPidlOut);
SHChangeNotify (bIsFolder ? SHCNE_RENAMEFOLDER : SHCNE_RENAMEITEM,
SHCNF_PATHW, szSrc, szDest);
return hr;
}
return E_FAIL;
}