/***********************************************************************
* 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;
}
/**************************************************************************
* CDesktopFolder::GetDisplayNameOf
*
* NOTES
* special case: pidl = null gives desktop-name back
*/
HRESULT WINAPI CDesktopFolder::GetDisplayNameOf(PCUITEMID_CHILD pidl, DWORD dwFlags, LPSTRRET strRet)
{
TRACE ("(%p)->(pidl=%p,0x%08x,%p)\n", this, pidl, dwFlags, strRet);
pdump (pidl);
if (!strRet)
return E_INVALIDARG;
if (!_ILIsPidlSimple (pidl))
{
return SHELL32_GetDisplayNameOfChild(this, pidl, dwFlags, strRet);
}
else if (_ILIsDesktop(pidl))
{
if ((GET_SHGDN_RELATION(dwFlags) == SHGDN_NORMAL) && (GET_SHGDN_FOR(dwFlags) & SHGDN_FORPARSING))
return SHSetStrRet(strRet, sPathTarget);
else
return HCR_GetClassName(CLSID_ShellDesktop, strRet);
}
/* file system folder or file rooted at the desktop */
CComPtr<IShellFolder2> psf;
HRESULT hr = _GetSFFromPidl(pidl, &psf);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
return psf->GetDisplayNameOf(pidl, dwFlags, strRet);
}
/**************************************************************************
* ISF_ControlPanel_fnGetDisplayNameOf
*/
static HRESULT WINAPI ISF_ControlPanel_fnGetDisplayNameOf(IShellFolder2 * iface, LPCITEMIDLIST pidl, DWORD dwFlags, LPSTRRET strRet)
{
ICPanelImpl *This = (ICPanelImpl *)iface;
CHAR szPath[MAX_PATH];
WCHAR wszPath[MAX_PATH+1]; /* +1 for potential backslash */
PIDLCPanelStruct* pcpanel;
*szPath = '\0';
TRACE("(%p)->(pidl=%p,0x%08lx,%p)\n", This, pidl, dwFlags, strRet);
pdump(pidl);
if (!pidl || !strRet)
return E_INVALIDARG;
pcpanel = _ILGetCPanelPointer(pidl);
if (pcpanel) {
lstrcpyA(szPath, pcpanel->szName+pcpanel->offsDispName);
if (!(dwFlags & SHGDN_FORPARSING))
FIXME("retrieve display name from control panel app\n");
}
/* take names of special folders only if its only this folder */
else if (_ILIsSpecialFolder(pidl)) {
BOOL bSimplePidl = _ILIsPidlSimple(pidl);
if (bSimplePidl) {
_ILSimpleGetTextW(pidl, wszPath, MAX_PATH); /* append my own path */
} else {
FIXME("special pidl\n");
}
if ((dwFlags & SHGDN_FORPARSING) && !bSimplePidl) { /* go deeper if needed */
int len = 0;
PathAddBackslashW(wszPath);
len = lstrlenW(wszPath);
if (!SUCCEEDED
(SHELL32_GetDisplayNameOfChild(iface, pidl, dwFlags | SHGDN_INFOLDER, wszPath + len, MAX_PATH + 1 - len)))
return E_OUTOFMEMORY;
if (!WideCharToMultiByte(CP_ACP, 0, wszPath, -1, szPath, MAX_PATH, NULL, NULL))
wszPath[0] = '\0';
}
}
strRet->uType = STRRET_CSTR;
lstrcpynA(strRet->u.cStr, szPath, MAX_PATH);
TRACE("--(%p)->(%s)\n", This, szPath);
return S_OK;
}
HRESULT SHELL32_BindToGuidItem(LPCITEMIDLIST pidlRoot,
PCUIDLIST_RELATIVE pidl,
LPBC pbcReserved,
REFIID riid,
LPVOID *ppvOut)
{
CComPtr<IPersistFolder> pFolder;
HRESULT hr;
if (!pidlRoot || !ppvOut || !pidl || !pidl->mkid.cb)
return E_INVALIDARG;
*ppvOut = NULL;
GUID *pGUID = _ILGetGUIDPointer(pidl);
if (!pGUID)
{
ERR("SHELL32_BindToGuidItem called for non guid item!\n");
return E_INVALIDARG;
}
hr = SHCoCreateInstance(NULL, pGUID, NULL, IID_PPV_ARG(IPersistFolder, &pFolder));
if (FAILED(hr))
return hr;
if (_ILIsPidlSimple (pidl))
{
hr = pFolder->Initialize(ILCombine(pidlRoot, pidl));
if (FAILED(hr))
return hr;
return pFolder->QueryInterface(riid, ppvOut);
}
else
{
LPITEMIDLIST pidlChild = ILCloneFirst (pidl);
if (!pidlChild)
return E_OUTOFMEMORY;
hr = pFolder->Initialize(ILCombine(pidlRoot, pidlChild));
ILFree(pidlChild);
if (FAILED(hr))
return hr;
CComPtr<IShellFolder> psf;
hr = pFolder->QueryInterface(IID_PPV_ARG(IShellFolder, &psf));
if (FAILED(hr))
return hr;
return psf->BindToObject(ILGetNext (pidl), pbcReserved, riid, ppvOut);
}
}
HRESULT SHELL32_BindToSF (LPCITEMIDLIST pidlRoot, PERSIST_FOLDER_TARGET_INFO* ppfti,
LPCITEMIDLIST pidl, const GUID* clsid, REFIID riid, LPVOID *ppvOut)
{
PITEMID_CHILD pidlChild = ILCloneFirst (pidl);
if (!pidlChild)
return E_FAIL;
CComPtr<IShellFolder> psf;
HRESULT hr = SHELL32_CoCreateInitSF(pidlRoot,
ppfti,
pidlChild,
clsid,
IID_PPV_ARG(IShellFolder, &psf));
ILFree(pidlChild);
if (FAILED_UNEXPECTEDLY(hr))
return hr;
if (_ILIsPidlSimple (pidl))
return psf->QueryInterface(riid, ppvOut);
else
return psf->BindToObject(ILGetNext (pidl), NULL, riid, ppvOut);
}
HRESULT WINAPI CRegFolder::BindToObject(PCUIDLIST_RELATIVE pidl, LPBC pbcReserved, REFIID riid, LPVOID *ppvOut)
{
CComPtr<IPersistFolder> pFolder;
HRESULT hr;
if (!ppvOut || !pidl || !pidl->mkid.cb)
return E_INVALIDARG;
*ppvOut = NULL;
GUID *pGUID = _ILGetGUIDPointer(pidl);
if (!pGUID)
{
ERR("CRegFolder::BindToObject called for non guid item!\n");
return E_INVALIDARG;
}
LPITEMIDLIST pidlChild = ILCloneFirst (pidl);
if (!pidlChild)
return E_OUTOFMEMORY;
CComPtr<IShellFolder> psf;
hr = SHELL32_CoCreateInitSF(m_pidlRoot, NULL, pidlChild, pGUID, -1, IID_PPV_ARG(IShellFolder, &psf));
ILFree(pidlChild);
if (FAILED(hr))
return hr;
if (_ILIsPidlSimple (pidl))
{
return psf->QueryInterface(riid, ppvOut);
}
else
{
return psf->BindToObject(ILGetNext (pidl), pbcReserved, riid, ppvOut);
}
}
/******************************************************************************
* HCR_GetFolderAttributes [Internal]
*
* Query the registry for a shell folders' attributes
*
* PARAMS
* pidlFolder [I] A simple pidl of type PT_GUID.
* pdwAttributes [IO] In: Attributes to be queried, OUT: Resulting attributes.
*
* RETURNS
* TRUE: Found information for the attributes in the registry
* FALSE: No attribute information found
*
* NOTES
* If queried for an attribute, which is set in the CallForAttributes registry
* value, the function binds to the shellfolder objects and queries it.
*/
BOOL HCR_GetFolderAttributes(LPCITEMIDLIST pidlFolder, LPDWORD pdwAttributes)
{
HKEY hSFKey;
LPOLESTR pwszCLSID;
LONG lResult;
DWORD dwTemp, dwLen;
static const WCHAR wszAttributes[] = { 'A','t','t','r','i','b','u','t','e','s',0 };
static const WCHAR wszCallForAttributes[] = {
'C','a','l','l','F','o','r','A','t','t','r','i','b','u','t','e','s',0 };
WCHAR wszShellFolderKey[] = { 'C','L','S','I','D','\\','{','0','0','0','2','1','4','0','0','-',
'0','0','0','0','-','0','0','0','0','-','C','0','0','0','-','0','0','0','0','0','0','0',
'0','0','0','4','6','}','\\','S','h','e','l','l','F','o','l','d','e','r',0 };
TRACE("(pidlFolder=%p, pdwAttributes=%p)\n", pidlFolder, pdwAttributes);
if (!_ILIsPidlSimple(pidlFolder)) {
static BOOL firstHit = TRUE;
if (firstHit) {
ERR("should be called for simple PIDL's only!\n");
firstHit = FALSE;
}
return FALSE;
}
if (!_ILIsDesktop(pidlFolder)) {
if (FAILED(StringFromCLSID(_ILGetGUIDPointer(pidlFolder), &pwszCLSID))) return FALSE;
memcpy(&wszShellFolderKey[6], pwszCLSID, 38 * sizeof(WCHAR));
CoTaskMemFree(pwszCLSID);
}
lResult = RegOpenKeyExW(HKEY_CLASSES_ROOT, wszShellFolderKey, 0, KEY_READ, &hSFKey);
#ifdef __REACTOS__
if (lResult != ERROR_SUCCESS)
{
ERR("Cannot open key: %ls\n", wszShellFolderKey);
return FALSE;
}
#else
if (lResult != ERROR_SUCCESS) return FALSE;
#endif
dwLen = sizeof(DWORD);
lResult = RegQueryValueExW(hSFKey, wszCallForAttributes, 0, NULL, (LPBYTE)&dwTemp, &dwLen);
if ((lResult == ERROR_SUCCESS) && (dwTemp & *pdwAttributes)) {
LPSHELLFOLDER psfDesktop, psfFolder;
HRESULT hr;
RegCloseKey(hSFKey);
hr = SHGetDesktopFolder(&psfDesktop);
if (SUCCEEDED(hr)) {
hr = IShellFolder_BindToObject(psfDesktop, pidlFolder, NULL, &IID_IShellFolder,
(LPVOID*)&psfFolder);
if (SUCCEEDED(hr)) {
hr = IShellFolder_GetAttributesOf(psfFolder, 0, NULL, pdwAttributes);
IShellFolder_Release(psfFolder);
}
IShellFolder_Release(psfDesktop);
}
if (FAILED(hr)) return FALSE;
} else {
lResult = RegQueryValueExW(hSFKey, wszAttributes, 0, NULL, (LPBYTE)&dwTemp, &dwLen);
RegCloseKey(hSFKey);
if (lResult == ERROR_SUCCESS) {
*pdwAttributes &= dwTemp;
} else {
return FALSE;
}
}
TRACE("-- *pdwAttributes == 0x%08x\n", *pdwAttributes);
return TRUE;
}
/**************************************************************************
* ISF_Desktop_fnGetDisplayNameOf
*
* NOTES
* special case: pidl = null gives desktop-name back
*/
static HRESULT WINAPI ISF_Desktop_fnGetDisplayNameOf (IShellFolder2 * iface,
LPCITEMIDLIST pidl, DWORD dwFlags, LPSTRRET strRet)
{
IDesktopFolderImpl *This = impl_from_IShellFolder2(iface);
HRESULT hr = S_OK;
LPWSTR pszPath;
TRACE ("(%p)->(pidl=%p,0x%08x,%p)\n", This, pidl, dwFlags, strRet);
pdump (pidl);
if (!strRet)
return E_INVALIDARG;
pszPath = CoTaskMemAlloc((MAX_PATH +1) * sizeof(WCHAR));
if (!pszPath)
return E_OUTOFMEMORY;
if (_ILIsDesktop (pidl))
{
if ((GET_SHGDN_RELATION (dwFlags) == SHGDN_NORMAL) &&
(GET_SHGDN_FOR (dwFlags) & SHGDN_FORPARSING))
strcpyW(pszPath, This->sPathTarget);
else
HCR_GetClassNameW(&CLSID_ShellDesktop, pszPath, MAX_PATH);
}
else if (_ILIsPidlSimple (pidl))
{
GUID const *clsid;
if ((clsid = _ILGetGUIDPointer (pidl)))
{
if (GET_SHGDN_FOR (dwFlags) & SHGDN_FORPARSING)
{
int bWantsForParsing;
/*
* We can only get a filesystem path from a shellfolder if the
* value WantsFORPARSING in CLSID\\{...}\\shellfolder exists.
*
* Exception: The MyComputer folder doesn't have this key,
* but any other filesystem backed folder it needs it.
*/
if (IsEqualIID (clsid, &CLSID_MyComputer))
{
bWantsForParsing = TRUE;
}
else
{
/* get the "WantsFORPARSING" flag from the registry */
static const WCHAR clsidW[] =
{ 'C','L','S','I','D','\\',0 };
static const WCHAR shellfolderW[] =
{ '\\','s','h','e','l','l','f','o','l','d','e','r',0 };
static const WCHAR wantsForParsingW[] =
{ 'W','a','n','t','s','F','o','r','P','a','r','s','i','n',
'g',0 };
WCHAR szRegPath[100];
LONG r;
lstrcpyW (szRegPath, clsidW);
SHELL32_GUIDToStringW (clsid, &szRegPath[6]);
lstrcatW (szRegPath, shellfolderW);
r = SHGetValueW(HKEY_CLASSES_ROOT, szRegPath,
wantsForParsingW, NULL, NULL, NULL);
if (r == ERROR_SUCCESS)
bWantsForParsing = TRUE;
else
bWantsForParsing = FALSE;
}
if ((GET_SHGDN_RELATION (dwFlags) == SHGDN_NORMAL) &&
bWantsForParsing)
{
/*
* we need the filesystem path to the destination folder.
* Only the folder itself can know it
*/
hr = SHELL32_GetDisplayNameOfChild (iface, pidl, dwFlags,
pszPath,
MAX_PATH);
}
else
{
/* parsing name like ::{...} */
pszPath[0] = ':';
pszPath[1] = ':';
SHELL32_GUIDToStringW (clsid, &pszPath[2]);
}
}
else
{
/* user friendly name */
HCR_GetClassNameW (clsid, pszPath, MAX_PATH);
}
}
else
{
int cLen = 0;
/* file system folder or file rooted at the desktop */
if ((GET_SHGDN_FOR(dwFlags) == SHGDN_FORPARSING) &&
(GET_SHGDN_RELATION(dwFlags) != SHGDN_INFOLDER))
{
lstrcpynW(pszPath, This->sPathTarget, MAX_PATH - 1);
PathAddBackslashW(pszPath);
cLen = lstrlenW(pszPath);
}
_ILSimpleGetTextW(pidl, pszPath + cLen, MAX_PATH - cLen);
if (!_ILIsFolder(pidl))
SHELL_FS_ProcessDisplayFilename(pszPath, dwFlags);
}
}
else
{
/* a complex pidl, let the subfolder do the work */
hr = SHELL32_GetDisplayNameOfChild (iface, pidl, dwFlags,
pszPath, MAX_PATH);
}
if (SUCCEEDED(hr))
{
/* Win9x always returns ANSI strings, NT always returns Unicode strings */
if (GetVersion() & 0x80000000)
{
strRet->uType = STRRET_CSTR;
if (!WideCharToMultiByte(CP_ACP, 0, pszPath, -1, strRet->u.cStr, MAX_PATH,
NULL, NULL))
strRet->u.cStr[0] = '\0';
CoTaskMemFree(pszPath);
}
else
{
strRet->uType = STRRET_WSTR;
strRet->u.pOleStr = pszPath;
}
}
else
CoTaskMemFree(pszPath);
TRACE ("-- (%p)->(%s,0x%08x)\n", This,
strRet->uType == STRRET_CSTR ? strRet->u.cStr :
debugstr_w(strRet->u.pOleStr), hr);
return hr;
}
/**************************************************************************
* DoOpenProperties
*/
static void DoOpenProperties(ItemCmImpl *This, HWND hwnd)
{
static const UINT MAX_PROP_PAGES = 99;
static const WCHAR wszFolder[] = {'F','o','l','d','e','r', 0};
static const WCHAR wszFiletypeAll[] = {'*',0};
LPSHELLFOLDER lpDesktopSF;
LPSHELLFOLDER lpSF;
LPDATAOBJECT lpDo;
WCHAR wszFiletype[MAX_PATH];
WCHAR wszFilename[MAX_PATH];
PROPSHEETHEADERW psh;
HPROPSHEETPAGE hpages[MAX_PROP_PAGES];
HPSXA hpsxa;
UINT ret;
TRACE("(%p)->(wnd=%p)\n", This, hwnd);
ZeroMemory(&psh, sizeof(PROPSHEETHEADERW));
psh.dwSize = sizeof (PROPSHEETHEADERW);
psh.hwndParent = hwnd;
psh.dwFlags = PSH_PROPTITLE;
psh.nPages = 0;
psh.u3.phpage = hpages;
psh.u2.nStartPage = 0;
_ILSimpleGetTextW(This->apidl[0], (LPVOID)&wszFilename, MAX_PATH);
psh.pszCaption = (LPCWSTR)&wszFilename;
/* Find out where to look for the shell extensions */
if (_ILIsValue(This->apidl[0]))
{
char sTemp[64];
sTemp[0] = 0;
if (_ILGetExtension(This->apidl[0], sTemp, 64))
{
HCR_MapTypeToValueA(sTemp, sTemp, 64, TRUE);
MultiByteToWideChar(CP_ACP, 0, sTemp, -1, wszFiletype, MAX_PATH);
}
else
{
wszFiletype[0] = 0;
}
}
else if (_ILIsFolder(This->apidl[0]))
{
lstrcpynW(wszFiletype, wszFolder, 64);
}
else if (_ILIsSpecialFolder(This->apidl[0]))
{
LPGUID folderGUID;
static const WCHAR wszclsid[] = {'C','L','S','I','D','\\', 0};
folderGUID = _ILGetGUIDPointer(This->apidl[0]);
lstrcpyW(wszFiletype, wszclsid);
StringFromGUID2(folderGUID, &wszFiletype[6], MAX_PATH - 6);
}
else
{
FIXME("Requested properties for unknown type.\n");
return;
}
/* Get a suitable DataObject for accessing the files */
SHGetDesktopFolder(&lpDesktopSF);
if (_ILIsPidlSimple(This->pidl))
{
ret = IShellFolder_GetUIObjectOf(lpDesktopSF, hwnd, This->cidl, (LPCITEMIDLIST*)This->apidl,
&IID_IDataObject, NULL, (LPVOID *)&lpDo);
IShellFolder_Release(lpDesktopSF);
}
else
{
IShellFolder_BindToObject(lpDesktopSF, This->pidl, NULL, &IID_IShellFolder, (LPVOID*) &lpSF);
ret = IShellFolder_GetUIObjectOf(lpSF, hwnd, This->cidl, (LPCITEMIDLIST*)This->apidl,
&IID_IDataObject, NULL, (LPVOID *)&lpDo);
IShellFolder_Release(lpSF);
IShellFolder_Release(lpDesktopSF);
}
if (SUCCEEDED(ret))
{
hpsxa = SHCreatePropSheetExtArrayEx(HKEY_CLASSES_ROOT, wszFiletype, MAX_PROP_PAGES - psh.nPages, lpDo);
if (hpsxa != NULL)
{
SHAddFromPropSheetExtArray(hpsxa, Properties_AddPropSheetCallback, (LPARAM)&psh);
SHDestroyPropSheetExtArray(hpsxa);
}
hpsxa = SHCreatePropSheetExtArrayEx(HKEY_CLASSES_ROOT, wszFiletypeAll, MAX_PROP_PAGES - psh.nPages, lpDo);
if (hpsxa != NULL)
{
SHAddFromPropSheetExtArray(hpsxa, Properties_AddPropSheetCallback, (LPARAM)&psh);
SHDestroyPropSheetExtArray(hpsxa);
}
IDataObject_Release(lpDo);
}
if (psh.nPages)
PropertySheetW(&psh);
else
FIXME("No property pages found.\n");
}
/***********************************************************************
* 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;
}
/**************************************************************************
* CControlPanelFolder::GetDisplayNameOf
*/
HRESULT WINAPI CControlPanelFolder::GetDisplayNameOf(PCUITEMID_CHILD pidl, DWORD dwFlags, LPSTRRET strRet)
{
CHAR szName[MAX_PATH];
WCHAR wszName[MAX_PATH+1]; /* +1 for potential backslash */
PIDLCPanelStruct *pCPanel;
HRESULT hr;
*szName = '\0';
TRACE("(%p)->(pidl=%p,0x%08x,%p)\n", this, pidl, dwFlags, strRet);
pdump(pidl);
if (!pidl)
return S_FALSE;
pCPanel = _ILGetCPanelPointer(pidl);
if (pCPanel)
{
/* copy display name from pidl - it was retrived from applet before;
SHGDN_FORPARSING does not need special handling */
lstrcpyA(szName, pCPanel->szName + pCPanel->offsDispName);
}
/* take names of special folders only if it's only this folder */
else if (_ILIsSpecialFolder(pidl))
{
BOOL bSimplePidl = _ILIsPidlSimple(pidl);
SFGAOF Attr = SFGAO_FILESYSTEM;
SHELL32_GetItemAttributes(this, pidl, &Attr);
if (Attr & SFGAO_FILESYSTEM)
{
hr = SHELL32_GetDisplayNameOfChild(this, pidl, dwFlags, wszName, sizeof(wszName));
if (FAILED(hr))
return hr;
}
else if (bSimplePidl)
{
_ILSimpleGetTextW(pidl, wszName, MAX_PATH); /* append my own path */
}
else
{
FIXME("special pidl\n");
if (dwFlags & SHGDN_FORPARSING)
{
/* go deeper if needed */
int cchName;
PathAddBackslashW(wszName);
cchName = wcslen(wszName);
hr = SHELL32_GetDisplayNameOfChild(this, pidl, dwFlags, wszName + cchName, MAX_PATH + 1 - cchName);
if (FAILED(hr))
return hr;
}
}
if (!WideCharToMultiByte(CP_ACP, 0, wszName, -1, szName, MAX_PATH, NULL, NULL))
szName[0] = '\0';
}
strRet->uType = STRRET_CSTR;
lstrcpynA(strRet->cStr, szName, MAX_PATH);
TRACE("--(%p)->(%s)\n", this, szName);
return S_OK;
}
/**************************************************************************
* CAdminToolsFolder::GetDisplayNameOf
*
*/
HRESULT WINAPI CAdminToolsFolder::GetDisplayNameOf(LPCITEMIDLIST pidl, DWORD dwFlags, LPSTRRET strRet)
{
HRESULT hr = S_OK;
LPWSTR pszPath, pOffset;
TRACE ("(%p)->(pidl=%p,0x%08x,%p)\n", this, pidl, dwFlags, strRet);
pdump (pidl);
if (!strRet)
return E_INVALIDARG;
pszPath = (LPWSTR)CoTaskMemAlloc((MAX_PATH + 1) * sizeof(WCHAR));
if (!pszPath)
return E_OUTOFMEMORY;
ZeroMemory(pszPath, (MAX_PATH + 1) * sizeof(WCHAR));
if (!pidl->mkid.cb)
{
if ((GET_SHGDN_RELATION (dwFlags) == SHGDN_NORMAL) &&
(GET_SHGDN_FOR (dwFlags) & SHGDN_FORPARSING))
wcscpy(pszPath, szTarget);
else if (!HCR_GetClassNameW(CLSID_AdminFolderShortcut, pszPath, MAX_PATH))
hr = E_FAIL;
}
else if (_ILIsPidlSimple(pidl))
{
if ((GET_SHGDN_FOR(dwFlags) & SHGDN_FORPARSING) &&
(GET_SHGDN_RELATION(dwFlags) != SHGDN_INFOLDER) &&
szTarget)
{
wcscpy(pszPath, szTarget);
pOffset = PathAddBackslashW(pszPath);
if (pOffset)
{
if (!_ILSimpleGetTextW(pidl, pOffset, MAX_PATH + 1 - (pOffset - pszPath)))
hr = E_FAIL;
}
else
hr = E_FAIL;
}
else
{
if (_ILSimpleGetTextW(pidl, pszPath, MAX_PATH + 1))
{
if (SHELL_FS_HideExtension(pszPath))
PathRemoveExtensionW(pszPath);
}
else
hr = E_FAIL;
}
}
else if (_ILIsSpecialFolder(pidl))
{
BOOL bSimplePidl = _ILIsPidlSimple(pidl);
if (bSimplePidl)
{
if (!_ILSimpleGetTextW(pidl, pszPath, MAX_PATH))
hr = E_FAIL;
}
else if ((dwFlags & SHGDN_FORPARSING) && !bSimplePidl)
{
int len = 0;
wcscpy(pszPath, szTarget);
PathAddBackslashW(pszPath);
len = wcslen(pszPath);
if (!SUCCEEDED(SHELL32_GetDisplayNameOfChild(this, pidl, dwFlags | SHGDN_INFOLDER, pszPath + len, MAX_PATH + 1 - len)))
{
CoTaskMemFree(pszPath);
return E_OUTOFMEMORY;
}
}
}
if (SUCCEEDED(hr))
{
strRet->uType = STRRET_WSTR;
strRet->pOleStr = pszPath;
TRACE ("-- (%p)->(%s,0x%08x)\n", this, debugstr_w(strRet->pOleStr), hr);
}
else
CoTaskMemFree(pszPath);
return hr;
}
