#include "shellprv.h" #pragma hdrstop #include "ole2dup.h" #include "copy.h" #include #include #include #include "_security.h" #include "ovrlaymn.h" #include "filefldr.h" #include "drives.h" #include "netview.h" #include #include "shitemid.h" #include "infotip.h" #include "recdocs.h" #include #include "datautil.h" #include "deskfldr.h" #include "prop.h" // COLUMN_INFO #include // IFilter stuff #include #include #include #include #include "folder.h" #include "ids.h" #include "category.h" #include "stgenum.h" #include "clsobj.h" #include "stgutil.h" #include "sfstorage.h" #include "mtpt.h" #include "defcm.h" STDAPI CFolderInfoTip_CreateInstance(IUnknown *punkOutter, LPCTSTR pszFolder, REFIID riid, void **ppv); #define SHCF_IS_BROWSABLE (SHCF_IS_SHELLEXT | SHCF_IS_DOCOBJECT) #define CSIDL_NORMAL ((UINT)-2) // has to not be -1 // File-scope pointer to a ShellIconOverlayManager // Callers access this pointer through GetIconOverlayManager(). static IShellIconOverlayManager * g_psiom = NULL; // #define FULL_DEBUG TCHAR const c_szCLSIDSlash[] = TEXT("CLSID\\"); TCHAR const c_szShellOpenCmd[] = TEXT("shell\\open\\command"); TCHAR g_szFolderTypeName[32] = TEXT(""); // "Folder" TCHAR g_szFileTypeName[32] = TEXT(""); // "File" TCHAR g_szFileTemplate[32] = TEXT(""); // "ext File" enum { FS_ICOL_NAME = 0, FS_ICOL_SIZE, FS_ICOL_TYPE, FS_ICOL_WRITETIME, FS_ICOL_CREATETIME, FS_ICOL_ACCESSTIME, FS_ICOL_ATTRIB, FS_ICOL_CSC_STATUS, }; const COLUMN_INFO c_fs_cols[] = { DEFINE_COL_STR_ENTRY(SCID_NAME, 30, IDS_NAME_COL), DEFINE_COL_SIZE_ENTRY(SCID_SIZE, IDS_SIZE_COL), DEFINE_COL_STR_ENTRY(SCID_TYPE, 20, IDS_TYPE_COL), DEFINE_COL_DATE_ENTRY(SCID_WRITETIME, IDS_MODIFIED_COL), // these are off by default (don't have SHCOLSTATE_ONBYDEFAULT) set DEFINE_COL_ENTRY(SCID_CREATETIME, VT_DATE, LVCFMT_LEFT, 20, SHCOLSTATE_TYPE_DATE, IDS_EXCOL_CREATE), DEFINE_COL_ENTRY(SCID_ACCESSTIME, VT_DATE, LVCFMT_LEFT, 20, SHCOLSTATE_TYPE_DATE | SHCOLSTATE_SECONDARYUI, IDS_EXCOL_ACCESSTIME), DEFINE_COL_ENTRY(SCID_ATTRIBUTES, VT_LPWSTR, LVCFMT_LEFT, 10, SHCOLSTATE_TYPE_STR, IDS_ATTRIB_COL), DEFINE_COL_STR_DLG_ENTRY(SCID_CSC_STATUS, 10, IDS_CSC_STATUS), }; // // List of file attribute bit values. The order (with respect // to meaning) must match that of the characters in g_szAttributeChars[]. // const DWORD g_adwAttributeBits[] = { FILE_ATTRIBUTE_READONLY, FILE_ATTRIBUTE_HIDDEN, FILE_ATTRIBUTE_SYSTEM, FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_COMPRESSED, FILE_ATTRIBUTE_ENCRYPTED, FILE_ATTRIBUTE_OFFLINE }; // // Buffer for characters that represent attributes in Details View attributes // column. Must provide room for 1 character for each bit a NUL. The current 5 // represent Read-only, Archive, Compressed, Hidden and System in that order. // This can't be const because we overwrite it using LoadString. // TCHAR g_szAttributeChars[ARRAYSIZE(g_adwAttributeBits) + 1] = { 0 } ; // order here is important, first one found will terminate the search const int c_csidlSpecial[] = { CSIDL_STARTMENU | TEST_SUBFOLDER, CSIDL_COMMON_STARTMENU | TEST_SUBFOLDER, CSIDL_RECENT, CSIDL_WINDOWS, CSIDL_SYSTEM, CSIDL_PERSONAL, CSIDL_FONTS }; BOOL CFSFolder::_IsCSIDL(UINT csidl) { BOOL bRet = (_csidl == csidl); if (!bRet) { TCHAR szPath[MAX_PATH]; _GetPath(szPath); bRet = PathIsEqualOrSubFolder(MAKEINTRESOURCE(csidl), szPath); if (bRet) _csidl = csidl; } return bRet; } UINT CFSFolder::_GetCSIDL() { // Cache the special folder ID, if it is not cached yet. if (_csidl == -1) { TCHAR szPath[MAX_PATH]; _GetPath(szPath); // Always cache the real Csidl. _csidl = GetSpecialFolderID(szPath, c_csidlSpecial, ARRAYSIZE(c_csidlSpecial)); if (_csidl == -1) { _csidl = CSIDL_NORMAL; // default } } return _csidl; } STDAPI_(LPCIDFOLDER) CFSFolder::_IsValidID(LPCITEMIDLIST pidl) { if (pidl && pidl->mkid.cb && (((LPCIDFOLDER)pidl)->bFlags & SHID_GROUPMASK) == SHID_FS) return (LPCIDFOLDER)pidl; return NULL; } // folder.{guid} or file.{guid} // system | readonly folder with desktop.ini and CLSID={guid} in the desktop.ini // file.ext where ext corresponds to a shell extension (such as .cab/.zip) // see _MarkAsJunction inline BOOL CFSFolder::_IsJunction(LPCIDFOLDER pidf) { return pidf->bFlags & SHID_JUNCTION; } inline BYTE CFSFolder::_GetType(LPCIDFOLDER pidf) { return pidf->bFlags & SHID_FS_TYPEMASK; } // this tests for old simple pidls that use SHID_FS // typically this only happens with persisted pidls in upgrade scenarios (shortcuts in the start menu) inline BOOL CFSFolder::_IsSimpleID(LPCIDFOLDER pidf) { return _GetType(pidf) == SHID_FS; } inline LPIDFOLDER CFSFolder::_FindLastID(LPCIDFOLDER pidf) { return (LPIDFOLDER)ILFindLastID((LPITEMIDLIST)pidf); } inline LPIDFOLDER CFSFolder::_Next(LPCIDFOLDER pidf) { return (LPIDFOLDER)_ILNext((LPITEMIDLIST)pidf); } // special marking for "All Users" items on the desktop (this is a hack to support the desktop // folder delegating to the approprate shell folder and is not generally useful) BOOL CFSFolder::_IsCommonItem(LPCITEMIDLIST pidl) { if (pidl && pidl->mkid.cb && (((LPCIDFOLDER)pidl)->bFlags & (SHID_GROUPMASK | SHID_FS_COMMONITEM)) == SHID_FS_COMMONITEM) return TRUE; return FALSE; } // a win32 file (might be a shell extension .cab/.zip that behaves like a folder) BOOL CFSFolder::_IsFile(LPCIDFOLDER pidf) { BOOL bRet = _GetType(pidf) == SHID_FS_FILE || _GetType(pidf) == SHID_FS_FILEUNICODE; // if it's a file, it shouldn't be a folder. // if it's not a file, usually it's a folder -- except if the type is SHID_FS, // that's okay too because it's a simple pidl in a .lnk from a downlevel shell. ASSERT(bRet ? !_IsFolder(pidf) : (_IsFolder(pidf) || _IsSimpleID(pidf))); return bRet; } // it is a win32 file system folder (maybe a junction, maybe not) BOOL CFSFolder::_IsFolder(LPCIDFOLDER pidf) { BOOL bRet = _GetType(pidf) == SHID_FS_DIRECTORY || _GetType(pidf) == SHID_FS_DIRUNICODE; ASSERT(bRet ? (pidf->wAttrs & FILE_ATTRIBUTE_DIRECTORY) : !(pidf->wAttrs & FILE_ATTRIBUTE_DIRECTORY)); return bRet; } // is it a file system folder that is not a junction BOOL CFSFolder::_IsFileFolder(LPCIDFOLDER pidf) { return _IsFolder(pidf) && !_IsJunction(pidf); } // non junction, but has the system or readonly bit (regular folder marked special for us) BOOL CFSFolder::_IsSystemFolder(LPCIDFOLDER pidf) { return _IsFileFolder(pidf) && (pidf->wAttrs & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)); } // this is a heuristic to determine if the IDList was created // normally or with a simple bind context (null size/mod date) BOOL CFSFolder::_IsReal(LPCIDFOLDER pidf) { return pidf->dwSize || pidf->dateModified ? TRUE : FALSE; } DWORD CFSFolder::_GetUID(LPCIDFOLDER pidf) { return pidf->dwSize + ((DWORD)pidf->dateModified << 8) + ((DWORD)pidf->timeModified << 12); } void CFSFolder::_GetSize(LPCITEMIDLIST pidlParent, LPCIDFOLDER pidf, ULONGLONG *pcbSize) { ULONGLONG cbSize = pidf->dwSize; if (cbSize != 0xFFFFFFFF) *pcbSize = cbSize; else if (pidlParent == NULL) *pcbSize = 0; else { HANDLE hfind; WIN32_FIND_DATA wfd = {0}; TCHAR szPath[MAX_PATH]; // Get the real size by asking the file system SHGetPathFromIDList(pidlParent, szPath); _AppendItemToPath(szPath, pidf); if (SHFindFirstFileRetry(NULL, NULL, szPath, &wfd, &hfind, SHPPFW_NONE) != S_OK) { *pcbSize = 0; } else { FindClose(hfind); ULARGE_INTEGER uli; uli.LowPart = wfd.nFileSizeLow; uli.HighPart = wfd.nFileSizeHigh; *pcbSize = uli.QuadPart; } } } ULONGLONG CFSFolder::_Size(LPCIDFOLDER pidf) { ULONGLONG cbSize; _GetSize(_pidl, pidf, &cbSize); return cbSize; } LPWSTR CFSFolder::_CopyName(LPCIDFOLDER pidf, LPWSTR pszName, UINT cchName) { CFileSysItem fsi(pidf); return (LPWSTR) fsi.MayCopyFSName(TRUE, pszName, cchName); } BOOL CFSFolder::_ShowExtension(LPCIDFOLDER pidf) { CFileSysItemString fsi(pidf); return fsi.ShowExtension(_DefaultShowExt()); } BOOL CFSFolder::_DefaultShowExt() { if (_tbDefShowExt == TRIBIT_UNDEFINED) { SHELLSTATE ss; SHGetSetSettings(&ss, SSF_SHOWEXTENSIONS, FALSE); _tbDefShowExt = ss.fShowExtensions ? TRIBIT_TRUE : TRIBIT_FALSE; } return _tbDefShowExt == TRIBIT_TRUE; } BOOL CFileSysItemString::ShowExtension(BOOL fDefaultShowExt) { DWORD dwFlags = ClassFlags(FALSE); if (dwFlags & SHCF_NEVER_SHOW_EXT) return FALSE; if (fDefaultShowExt) return TRUE; return dwFlags & (SHCF_ALWAYS_SHOW_EXT | SHCF_UNKNOWN); } // // get the type name from the registry, if the name is blank make // up a default. // // directory ==> "Folder" // foo ==> "File" // foo.xyz ==> "XYZ File" // void SHGetTypeName(LPCTSTR pszFile, HKEY hkey, BOOL fFolder, LPTSTR pszName, int cchNameMax) { LONG cb = cchNameMax * sizeof(TCHAR); if (hkey == NULL || SHRegQueryValue(hkey, NULL, pszName, &cb) != ERROR_SUCCESS || pszName[0] == 0) { if (fFolder) { // NOTE the registry doesn't have a name for Folder // because old apps would think it was a file type. lstrcpy(pszName, g_szFolderTypeName); } else { LPTSTR pszExt = PathFindExtension(pszFile); ASSERT(pszExt); if (*pszExt == 0) { // Probably don't need the cchmax here, but... lstrcpyn(pszName, g_szFileTypeName, cchNameMax); } else { TCHAR szExt[_MAX_EXT]; int cchMaxExtCopy = (int)min((cchNameMax - lstrlen(g_szFileTemplate)), ARRAYSIZE(szExt)); // Compose ' File' (or what ever the template defines we do) lstrcpyn(szExt, pszExt + 1, cchMaxExtCopy); CharUpperNoDBCS(szExt); wsprintf(pszName, g_szFileTemplate, szExt); } } } } // // return a pointer to the type name for the given PIDL // the pointer is only valid while in a critical section // LPCTSTR CFSFolder::_GetTypeName(LPCIDFOLDER pidf) { CFileSysItemString fsi(pidf); ASSERTCRITICAL LPCTSTR pszClassName = LookupFileClassName(fsi.Class()); if (pszClassName == NULL) { WCHAR sz[80]; IQueryAssociations *pqa; HRESULT hr = fsi.AssocCreate(NULL, FALSE, IID_PPV_ARG(IQueryAssociations, &pqa)); if (SUCCEEDED(hr)) { DWORD cch = ARRAYSIZE(sz); hr = pqa->GetString(0, ASSOCSTR_FRIENDLYDOCNAME, NULL, sz, &cch); if (SUCCEEDED(hr)) { pszClassName = AddFileClassName(fsi.Class(), sz); } pqa->Release(); } } return pszClassName; } // // return the type name for the given PIDL // HRESULT CFSFolder::_GetTypeNameBuf(LPCIDFOLDER pidf, LPTSTR pszName, int cchNameMax) { HRESULT hr = S_OK; ENTERCRITICAL; LPCTSTR pszSource = _GetTypeName(pidf); // pszSource will be NULL if the file does not have an extension. if (!pszSource) { pszSource = TEXT(""); // Terminate Buffer hr = E_FAIL; } StrCpyN(pszName, pszSource, cchNameMax); LEAVECRITICAL; return hr; } // // Build a text string containing characters that represent attributes of a file. // The attribute characters are assigned as follows: // (R)eadonly, (H)idden, (S)ystem, (A)rchive, (H)idden. // void BuildAttributeString(DWORD dwAttributes, LPTSTR pszString, UINT nChars) { // Make sure we have attribute chars to build this string out of if (!g_szAttributeChars[0]) LoadString(HINST_THISDLL, IDS_ATTRIB_CHARS, g_szAttributeChars, ARRAYSIZE(g_szAttributeChars)); // Make sure buffer is big enough to hold worst-case attributes ASSERT(nChars >= ARRAYSIZE(g_adwAttributeBits) + 1); for (int i = 0; i < ARRAYSIZE(g_adwAttributeBits); i++) { if (dwAttributes & g_adwAttributeBits[i]) *pszString++ = g_szAttributeChars[i]; } *pszString = 0; // null terminate } // BryanSt: This doesn't work with FRAGMENTs. We should return the path // without the Fragment for backward compatibility and then callers that care, // can later determine that and take care of it. // // in/out: // pszPath path to append pidf names to // in: // pidf relative pidl fragment HRESULT CFSFolder::_AppendItemToPath(LPTSTR pszPath, LPCIDFOLDER pidf) { HRESULT hr = S_OK; LPTSTR pszPathCur = pszPath + lstrlen(pszPath); // e want to do this, but we stil have broken code in SHGetPathFromIDList // ASSERT(_FindJunctionNext(pidf) == NULL); // no extra goo please for (; SUCCEEDED(hr) && !ILIsEmpty((LPITEMIDLIST)pidf); pidf = _Next(pidf)) { CFileSysItemString fsi(pidf); int cchName = lstrlen(fsi.FSName()); // store the length of szName, to avoid calculating it twice // mil 142338: handle bogus pidls that have multiple "C:"s in them // due to bad shortcut creation. if ((cchName == 2) && (fsi.FSName()[1] == TEXT(':'))) { pszPathCur = pszPath; } else { // ASSERT(lstrlen(pszPath)+lstrlen(szName)+2 <= MAX_PATH); if (((pszPathCur - pszPath) + cchName + 2) > MAX_PATH) { hr = HRESULT_FROM_WIN32(ERROR_BUFFER_OVERFLOW); // FormatMessage = "The file name is too long" break; } LPTSTR pszTmp = CharPrev(pszPath, pszPathCur); if (*pszTmp != TEXT('\\')) *(pszPathCur++) = TEXT('\\'); } // don't need lstrncpy cause we verified size above lstrcpy(pszPathCur, fsi.FSName()); pszPathCur += cchName; } if (FAILED(hr)) *pszPath = 0; return hr; } // get the file system folder path for this // // HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) is returned if we are a tracking // folder that does not (yet) have a valid target. HRESULT CFSFolder::_GetPath(LPTSTR pszPath) { HRESULT hr = E_FAIL; if (_csidlTrack >= 0) { hr = SHGetFolderPath(NULL, _csidlTrack | CSIDL_FLAG_DONT_VERIFY, NULL, SHGFP_TYPE_CURRENT, pszPath); if (hr == S_FALSE || FAILED(hr)) hr = HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND); } else if (_pszPath) { lstrcpyn(pszPath, _pszPath, MAX_PATH); hr = S_OK; } else { if (_pidlTarget && SUCCEEDED(SHGetNameAndFlags(_pidlTarget, SHGDN_FORPARSING, pszPath, MAX_PATH, NULL))) { _pszPath = StrDup(pszPath); hr = S_OK; } else if (SUCCEEDED(SHGetNameAndFlags(_pidl, SHGDN_FORPARSING, pszPath, MAX_PATH, NULL))) { _pszPath = StrDup(pszPath); hr = S_OK; } } if (hr==S_OK && !(*pszPath)) hr= E_FAIL; // old behavior was to fail if pszPath was empty return hr; } // Will fail (return FALSE) if not a mount point BOOL CFSFolder::_GetMountingPointInfo(LPCIDFOLDER pidf, LPTSTR pszMountPoint, DWORD cchMountPoint) { BOOL bRet = FALSE; // Is this a reparse point? if (FILE_ATTRIBUTE_REPARSE_POINT & pidf->wAttrs) { TCHAR szLocalMountPoint[MAX_PATH]; if (SUCCEEDED(_GetPathForItem(pidf, szLocalMountPoint))) { int iDrive = PathGetDriveNumber(szLocalMountPoint); if (-1 != iDrive) { TCHAR szDrive[4]; if (DRIVE_REMOTE != GetDriveType(PathBuildRoot(szDrive, iDrive))) { TCHAR szVolumeName[50]; //50 according to doc PathAddBackslash(szLocalMountPoint); // Check if it is a mounting point if (GetVolumeNameForVolumeMountPoint(szLocalMountPoint, szVolumeName, ARRAYSIZE(szVolumeName))) { bRet = TRUE; if (pszMountPoint && cchMountPoint) lstrcpyn(pszMountPoint, szLocalMountPoint, cchMountPoint); } } } } } return bRet; } // in: // pidf may be NULL, or multi level item to append to path for this folder // out: // pszPath MAX_PATH buffer to receive the fully qualified file path for the item // HRESULT CFSFolder::_GetPathForItem(LPCIDFOLDER pidf, LPWSTR pszPath) { if (SUCCEEDED(_GetPath(pszPath))) { if (pidf) { return _AppendItemToPath(pszPath, pidf); } return S_OK; } return E_FAIL; } HRESULT CFSFolder::_GetPathForItems(LPCIDFOLDER pidfParent, LPCIDFOLDER pidfLast, LPTSTR pszPath) { HRESULT hr = _GetPathForItem(pidfParent ? pidfParent : pidfLast, pszPath); if (SUCCEEDED(hr) && pidfParent) hr = _AppendItemToPath(pszPath, pidfLast); return hr; } BOOL _GetIniPath(BOOL fCreate, LPCTSTR pszFolder, LPCTSTR pszProvider, LPTSTR pszPath) { BOOL fExists = FALSE; PathCombine(pszPath, pszFolder, c_szDesktopIni); // CHECK for PathFileExists BEFORE calling to GetPrivateProfileString // because if the file isn't there (which is the majority of cases) // GetPrivateProfileString hits the disk twice looking for the file if (pszProvider && *pszProvider) { union { NETRESOURCE nr; TCHAR buf[512]; } nrb; LPTSTR lpSystem; DWORD dwRes, dwSize = sizeof(nrb); nrb.nr.dwType = RESOURCETYPE_ANY; nrb.nr.lpRemoteName = pszPath; nrb.nr.lpProvider = (LPTSTR)pszProvider; // const -> non const dwRes = WNetGetResourceInformation(&nrb.nr, &nrb, &dwSize, &lpSystem); fExists = (dwRes == WN_SUCCESS) || (dwRes == WN_MORE_DATA); } else { fExists = PathFileExists(pszPath); } if (fCreate && !fExists) { // we need to touch this file first HANDLE h = CreateFile(pszPath, 0, FILE_SHARE_DELETE, NULL, CREATE_NEW, FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM, NULL); if (INVALID_HANDLE_VALUE != h) { PathMakeSystemFolder(pszFolder); fExists = TRUE; CloseHandle(h); } } return fExists; } STDAPI_(BOOL) SetFolderString(BOOL fCreate, LPCTSTR pszFolder, LPCTSTR pszProvider, LPCTSTR pszSection, LPCTSTR pszKey, LPCTSTR pszData) { TCHAR szPath[MAX_PATH]; if (_GetIniPath(fCreate, pszFolder, pszProvider, szPath)) { return SHSetIniStringUTF7(pszSection, pszKey, pszData, szPath); } return FALSE; } // // This function retrieves the private profile strings from the desktop.ini file and // return it through pszOut // // This function uses SHGetIniStringUTF7 to get the string, so it is valid // to use SZ_CANBEUNICODE on the key name. BOOL GetFolderStringEx(LPCTSTR pszFolder, LPCTSTR pszProvider, LPCTSTR pszSection, LPCTSTR pszKey, LPTSTR pszOut, int cch) { BOOL fRet = FALSE; TCHAR szPath[MAX_PATH]; if (_GetIniPath(FALSE, pszFolder, pszProvider, szPath)) { TCHAR szTemp[INFOTIPSIZE]; fRet = SHGetIniStringUTF7(pszSection, pszKey, szTemp, ARRAYSIZE(szTemp), szPath); if (fRet) { SHExpandEnvironmentStrings(szTemp, pszOut, cch); // This could be a path, so expand the env vars in it } } return fRet; } int GetFolderInt(LPCTSTR pszFolder, LPCTSTR pszProvider, LPCTSTR pszSection, LPCTSTR pszKey, int iDefault) { BOOL fRet = FALSE; TCHAR szPath[MAX_PATH]; if (_GetIniPath(FALSE, pszFolder, pszProvider, szPath)) { return GetPrivateProfileInt(pszSection, pszKey, iDefault, szPath); } return iDefault; } STDAPI_(BOOL) GetFolderString(LPCTSTR pszFolder, LPCTSTR pszProvider, LPTSTR pszOut, int cch, LPCTSTR pszKey) { return GetFolderStringEx(pszFolder, pszProvider, STRINI_CLASSINFO, pszKey, pszOut, cch); } // This function retrieves the specifice GUID from desktop.ini file. // replace this with property bag access on the folder STDAPI_(BOOL) GetFolderGUID(LPCTSTR pszFolder, LPCTSTR pszProvider, CLSID* pclsid, LPCTSTR pszKey) { TCHAR szCLSID[40]; if (GetFolderString(pszFolder, pszProvider, szCLSID, ARRAYSIZE(szCLSID), pszKey)) { return SUCCEEDED(SHCLSIDFromString(szCLSID, pclsid)); } return FALSE; } // // This function retrieves the correct CLSID from desktop.ini file. // BOOL _GetFolderCLSID(LPCTSTR pszFolder, LPCTSTR pszProvider, CLSID* pclsid) { BOOL bFound = FALSE; WCHAR szPath[MAX_PATH]; if (_GetIniPath(FALSE, pszFolder, pszProvider, szPath)) { DWORD dwChars; WCHAR szSectionValue[1024]; dwChars = GetPrivateProfileSection(STRINI_CLASSINFO, szSectionValue, sizeof(szSectionValue), szPath); if (dwChars != (sizeof(szSectionValue) - 2) && (dwChars != 0)) { static WCHAR *const c_rgpsz[] = {TEXT("CLSID2"), TEXT("CLSID"), TEXT("UICLSID")}; int iFoundIndex = ARRAYSIZE(c_rgpsz); // We look for CLSID2, CLSID, then UICLSID, since there could be multiple kes in this section. // CLSID2 makes folders work on Win95 if the CLSID does not exist on the machine for (WCHAR *pNextKeyPointer = szSectionValue; *pNextKeyPointer; pNextKeyPointer += lstrlen(pNextKeyPointer) + 1) { PWCHAR pBuffer = pNextKeyPointer; PWCHAR pEqual = StrChrW(pBuffer, L'='); if (pEqual && (*(pEqual+1) != L'\0')) { *pEqual = L'\0'; for (int i = 0; i < ARRAYSIZE(c_rgpsz); i++) { if (StrCmpIC(c_rgpsz[i], pBuffer) == 0) { CLSID clsid; if ((iFoundIndex < i) && bFound) { break; } pBuffer += lstrlen(pBuffer) + 1; if (SUCCEEDED(SHCLSIDFromString(pBuffer, &clsid))) { if (i == ARRAYSIZE(c_rgpsz) - 1) { // hack for "Temporary Internet Files" if (clsid == CLSID_CacheFolder) { *pclsid = CLSID_CacheFolder2; bFound = TRUE; } } else { *pclsid = clsid; bFound = TRUE; } iFoundIndex = i; } break; } } // end of for } // end of if } //end of for } } return bFound; } LPTSTR PathFindCLSIDExtension(LPCTSTR pszFile, CLSID *pclsid) { LPCTSTR pszExt = PathFindExtension(pszFile); ASSERT(pszExt); if (*pszExt == TEXT('.') && *(pszExt + 1) == TEXT('{') /* '}' */) { CLSID clsid; if (pclsid == NULL) pclsid = &clsid; if (SUCCEEDED(SHCLSIDFromString(pszExt + 1, pclsid))) return (LPTSTR)pszExt; // const -> non const } return NULL; } // // This function retrieves the CLSID from a filename // file.{GUID} // BOOL _GetFileCLSID(LPCTSTR pszFile, CLSID* pclsid) { return PathFindCLSIDExtension(pszFile, pclsid) != NULL; } // test pidf for properties that make make it a junction, mark it as a junction // as needed, see _IsJunction usage BOOL _ClsidExists(REFGUID clsid) { HKEY hk; if (SUCCEEDED(SHRegGetCLSIDKey(clsid, NULL, FALSE, FALSE, &hk))) { RegCloseKey(hk); return TRUE; } return FALSE; } LPIDFOLDER CFSFolder::_MarkAsJunction(LPCIDFOLDER pidfSimpleParent, LPIDFOLDER pidf, LPCTSTR pszName) { CLSID clsid; BOOL fJunction = FALSE; // check for a junction point, junctions are either // Folder.{guid} or File.{guid} both fall into this case if (_GetFileCLSID(pszName, &clsid)) { fJunction = TRUE; } else if (_IsSystemFolder(pidf)) { // system (read only or system bit) look for the desktop.ini in a folder TCHAR szPath[MAX_PATH]; if (SUCCEEDED(_GetPathForItems(pidfSimpleParent, pidf, szPath))) { // CLSID2 makes folders work on Win95 if the CLSID does not exist on the machine if (_GetFolderCLSID(szPath, _pszNetProvider, &clsid)) { fJunction = TRUE; } } } if (fJunction && _ClsidExists(clsid)) { pidf->bFlags |= SHID_JUNCTION; pidf = (LPIDFOLDER) ILAppendHiddenClsid((LPITEMIDLIST)pidf, IDLHID_JUNCTION, &clsid); } return pidf; } BOOL CFSFolder::_GetJunctionClsid(LPCIDFOLDER pidf, CLSID *pclsid) { CFileSysItemString fsi(pidf); return fsi.GetJunctionClsid(pclsid, TRUE); } BOOL CFileSysItemString::GetJunctionClsid(CLSID *pclsid, BOOL fShellExtOk) { BOOL bRet = FALSE; *pclsid = CLSID_NULL; if (CFSFolder::_IsJunction(_pidf)) { // if this is a junction point that was created with a hidden CLSID // then it should be stored with IDLHID_JUNCTION if (ILGetHiddenClsid((LPCITEMIDLIST)_pidf, IDLHID_JUNCTION, pclsid)) bRet = TRUE; else { // it might be an oldstyle JUNCTION point that was persisted out or a ROOT_REGITEM if (SIL_GetType((LPITEMIDLIST)_pidf) == SHID_ROOT_REGITEM) { const UNALIGNED CLSID *pc = (UNALIGNED CLSID *)(((BYTE *)_pidf) + _pidf->cb - sizeof(CLSID)); *pclsid = *pc; bRet = TRUE; } } } else if (fShellExtOk) { if (ClassFlags(FALSE) & SHCF_IS_SHELLEXT) { IAssociationArray *paa; // must pass NULL for CFSFolder to avoid recursion if (SUCCEEDED(AssocCreate(NULL, FALSE, IID_PPV_ARG(IAssociationArray, &paa)))) { CSmartCoTaskMem spsz; if (SUCCEEDED(paa->QueryString(ASSOCELEM_MASK_QUERYNORMAL, AQS_CLSID, NULL, &spsz))) { bRet = GUIDFromString(spsz, pclsid); } paa->Release(); } } } else if (CFSFolder::_IsFolder(_pidf)) { // directory.{guid} is always of Class() {guid} bRet = _GetFileCLSID(FSName(), pclsid); } return bRet; } // // returns a unique name for a class, dont use this function to get // the ProgID for a class call SHGetClassKey() for that // // Returns: class name in pszClass // // foo.ext ".ext" // foo "." // (empty) "Folder" // directory "Directory" // junction "CLSID\{clsid}" // BOOL CFSFolder::_GetClass(LPCIDFOLDER pidf, LPTSTR pszClass, UINT cch) { CFileSysItemString fsi(pidf); StrCpyN(pszClass, fsi.Class(), cch); return TRUE; } LPCWSTR CFileSysItemString::_Class() { if (_pidf->cb == 0) // ILIsEmpty() { // the desktop. Always use the "Folder" class. _pszClass = c_szFolderClass; } // else if (ILGetHiddenString(IDLHID_TREATASCLASS)) else { CLSID clsid; if (GetJunctionClsid(&clsid, FALSE)) { // This is a junction point, get the CLSID from it. CSmartCoTaskMem spsz; if (SUCCEEDED(ProgIDFromCLSID(clsid, &spsz))) { StrCpyN(_sz, spsz, ARRAYSIZE(_sz)); } else SHStringFromGUID(clsid, _sz , ARRAYSIZE(_sz)); _fsin = FSINAME_CLASS; } else if (CFSFolder::_IsFolder(_pidf)) { // This is a directory. Always use the "Directory" class. // This can also be a Drive id. _pszClass = TEXT("Directory"); } else { // This is a file. Get the class based on the extension. LPCWSTR pszFile = FSName(); LPCWSTR pszExt = PathFindExtension(pszFile); ASSERT(pszExt); ASSERT(!(_pidf->wAttrs & FILE_ATTRIBUTE_DIRECTORY)); if (*pszExt == 0) { if (_pidf->wAttrs & FILE_ATTRIBUTE_SYSTEM) _pszClass = TEXT(".sys"); else _pszClass = TEXT("."); } else if (pszFile == _sz) { // we need the buffer to be setup correctly MoveMemory(_sz, pszExt, CbFromCchW(lstrlen(pszExt) + 1)); _fsin = FSINAME_CLASS; } else _pszClass = pszExt; } } ASSERT(_pszClass || *_sz); return _pszClass ? _pszClass : _sz; } LPCWSTR CFileSysItemString::Class() { if (!_pszClass) { if (!(_fsin & FSINAME_CLASS)) { return _Class(); } else { return _sz; } } return _pszClass; } CFSAssocEnumData::CFSAssocEnumData(BOOL fIsUnknown, CFSFolder *pfs, LPCIDFOLDER pidf) : _fIsUnknown(fIsUnknown) { _fIsSystemFolder = pfs->_IsSystemFolder(pidf); pfs->_GetPathForItem(pidf, _szPath); if (_fIsUnknown) _fIsUnknown = !(FILE_ATTRIBUTE_OFFLINE & pidf->wAttrs); else { if (CFSFolder::_IsFileFolder(pidf)) _pidl = ILCombine(pfs->_GetIDList(), (LPCITEMIDLIST)pidf); } } LPCWSTR _GetDirectoryClass(LPCWSTR pszPath, LPCITEMIDLIST pidl, BOOL fIsSystemFolder); BOOL CFSAssocEnumData::_Next(IAssociationElement **ppae) { HRESULT hr = E_FAIL; if (_fIsUnknown) { CLSID clsid; hr = GetClassFile(_szPath, &clsid); if (SUCCEEDED(hr)) { CSmartCoTaskMem spszProgid; hr = ProgIDFromCLSID(clsid, &spszProgid); if (SUCCEEDED(hr)) { hr = AssocElemCreateForClass(&CLSID_AssocProgidElement, spszProgid, ppae); } if (FAILED(hr)) { WCHAR sz[GUIDSTR_MAX]; SHStringFromGUIDW(clsid, sz, ARRAYSIZE(sz)); hr = AssocElemCreateForClass(&CLSID_AssocClsidElement, sz, ppae); } } if (FAILED(hr)) { hr = AssocElemCreateForClass(&CLSID_AssocShellElement, L"Unknown", ppae); } _fIsUnknown = FALSE; } if (FAILED(hr) && _pidl) { PCWSTR psz = _GetDirectoryClass(_szPath, _pidl, _fIsSystemFolder); if (psz) hr = AssocElemCreateForClass(&CLSID_AssocSystemElement, psz, ppae); ILFree(_pidl); _pidl = NULL; } return SUCCEEDED(hr); } class CFSAssocEnumExtra : public CEnumAssociationElements { public: protected: BOOL _Next(IAssociationElement **ppae); protected: }; BOOL CFSAssocEnumExtra::_Next(IAssociationElement **ppae) { if (_cNext == 0) { // corel wp suite 7 relies on the fact that send to menu is hard coded // not an extension so do not insert it (and the similar items) if (!(SHGetAppCompatFlags(ACF_CONTEXTMENU) & ACF_CONTEXTMENU)) { AssocElemCreateForClass(&CLSID_AssocShellElement, L"AllFilesystemObjects", ppae); } } return *ppae != NULL; } HRESULT CFileSysItemString::AssocCreate(CFSFolder *pfs, BOOL fForCtxMenu, REFIID riid, void **ppv) { // WARNING - the pfs keeps us from recursing. *ppv = NULL; IAssociationArrayInitialize *paai; HRESULT hr = ::AssocCreate(CLSID_QueryAssociations, IID_PPV_ARG(IAssociationArrayInitialize, &paai)); if (SUCCEEDED(hr)) { // the base class for directory's is always Folder ASSOCELEM_MASK base; if (CFSFolder::_IsFolder(_pidf)) base = ASSOCELEM_BASEIS_FOLDER; else { // for files it is always * base = ASSOCELEM_BASEIS_STAR; if (pfs) { CLSID clsid; if (GetJunctionClsid(&clsid, TRUE)) { // but if this file is also a folder (like .zip and .cab) // then we should also use Folder if (SHGetAttributesFromCLSID2(&clsid, 0, SFGAO_FOLDER) & SFGAO_FOLDER) base |= ASSOCELEM_BASEIS_FOLDER; } } } hr = paai->InitClassElements(base, Class()); if (SUCCEEDED(hr) && pfs) { BOOL fIsLink = fForCtxMenu && (_ClassFlags(paai, FALSE) & SHCF_IS_LINK); if (fIsLink) { // we dont like to do everything for LINK, but // maybe we should be adding BASEIS_STAR? paai->FilterElements(ASSOCELEM_DEFAULT | ASSOCELEM_EXTRA); } IEnumAssociationElements *penum = new CFSAssocEnumExtra(); if (penum) { paai->InsertElements(ASSOCELEM_EXTRA, penum); penum->Release(); } if (!fIsLink) { penum = new CFSAssocEnumData(hr == S_FALSE, pfs, _pidf); if (penum) { paai->InsertElements(ASSOCELEM_DATA | ASSOCELEMF_INCLUDE_SLOW, penum); penum->Release(); } } } if (SUCCEEDED(hr)) hr = paai->QueryInterface(riid, ppv); paai->Release(); } return hr; } HRESULT CFSFolder::_AssocCreate(LPCIDFOLDER pidf, REFIID riid, void **ppv) { CFileSysItemString fsi(pidf); return fsi.AssocCreate(this, FALSE, riid, ppv); } // // Description: This simulates the ComponentCategoryManager // call which checks to see if a CLSID is a member of a CATID. // STDAPI_(BOOL) IsMemberOfCategory(IAssociationArray *paa, REFCATID rcatid) { BOOL fRet = FALSE; CSmartCoTaskMem spsz; if (SUCCEEDED(paa->QueryString(ASSOCELEM_MASK_QUERYNORMAL, AQS_CLSID, NULL, &spsz))) { TCHAR szKey[GUIDSTR_MAX * 4], szCATID[GUIDSTR_MAX]; // Construct the registry key that detects if // a CLSID is a member of a CATID. SHStringFromGUID(rcatid, szCATID, ARRAYSIZE(szCATID)); wnsprintf(szKey, ARRAYSIZE(szKey), TEXT("CLSID\\%s\\Implemented Categories\\%s"), spsz, szCATID); // See if it's there. fRet = SHRegQueryValue(HKEY_CLASSES_ROOT, szKey, NULL, NULL) == ERROR_SUCCESS; } return fRet; } // get flags for a file class. // // given a FS PIDL returns a DWORD of flags, or 0 for error // // SHCF_ICON_INDEX this is this sys image index for per class // SHCF_ICON_PERINSTANCE icons are per instance (one per file) // SHCF_ICON_DOCICON icon is in shell\open\command (simulate doc icon) // // SHCF_HAS_ICONHANDLER set if class has a IExtractIcon handler // // SHCF_UNKNOWN set if extenstion is not registered // // SHCF_IS_LINK set if class is a link // SHCF_ALWAYS_SHOW_EXT always show the extension // SHCF_NEVER_SHOW_EXT never show the extension // DWORD CFSFolder::_GetClassFlags(LPCIDFOLDER pidf) { CFileSysItemString fsi(pidf); return fsi.ClassFlags(FALSE); } void CFileSysItemString::_QueryIconIndex(IAssociationArray *paa) { // check for the default icon under HKCU for this file extension. // null out the icon index _dwClass &= ~SHCF_ICON_INDEX; PWSTR pszIcon; HRESULT hr = E_FAIL; if (paa) { // check for icon in ProgID // Then, check if the default icon is specified in OLE-style. hr = paa->QueryString(ASSOCELEM_MASK_QUERYNORMAL, AQS_DEFAULTICON, NULL, &pszIcon); if (SUCCEEDED(hr)) { // hijack these icons // office XP has really ugly icons for images // and ours are so beautiful...office wont mind static const struct { PCWSTR pszUgly; PCWSTR pszPretty; } s_hijack[] = { { L"PEicons.exe,1", L"shimgvw.dll,2" }, // PNG { L"PEicons.exe,4", L"shimgvw.dll,2" }, // GIF { L"PEicons.exe,5", L"shimgvw.dll,3" }, // JPEG { L"MSPVIEW.EXE,1", L"shimgvw.dll,4" }, // TIF { L"wordicon.exe,8", L"moricons.dll,-109"}, { L"xlicons.exe,13", L"moricons.dll,-110"}, { L"accicons.exe,57", L"moricons.dll,-111"}, { L"pptico.exe,6", L"moricons.dll,-112"}, { L"fpicon.exe,2", L"moricons.dll,-113"}, }; PCWSTR pszName = PathFindFileName(pszIcon); for (int i = 0; i < ARRAYSIZE(s_hijack); i++) { if (0 == StrCmpIW(pszName, s_hijack[i].pszUgly)) { // replace this ugly chicken CoTaskMemFree(pszIcon); hr = SHStrDupW(s_hijack[i].pszPretty, &pszIcon); break; } } } else if (!CFSFolder::_IsFolder(_pidf)) { hr = paa->QueryString(ASSOCELEM_MASK_QUERYNORMAL, AQVS_APPLICATION_PATH, NULL, &pszIcon); if (SUCCEEDED(hr)) _dwClass |= SHCF_ICON_DOCICON; } } // Check if this is a per-instance icon if (SUCCEEDED(hr) && (lstrcmp(pszIcon, TEXT("%1")) == 0 || lstrcmp(pszIcon, TEXT("\"%1\"")) == 0)) { _dwClass &= ~SHCF_ICON_DOCICON; _dwClass |= SHCF_ICON_PERINSTANCE; } else { int iIcon, iImage; if (SUCCEEDED(hr)) { iIcon = PathParseIconLocation(pszIcon); iImage = Shell_GetCachedImageIndex(pszIcon, iIcon, _dwClass & SHCF_ICON_DOCICON ? GIL_SIMULATEDOC : 0); if (iImage == -1) { iIcon = _dwClass & SHCF_ICON_DOCICON ? II_DOCUMENT : II_DOCNOASSOC; iImage = Shell_GetCachedImageIndex(c_szShell32Dll, iIcon, 0); } } else { iIcon = CFSFolder::_IsFolder(_pidf) ? II_FOLDER : II_DOCNOASSOC; iImage = Shell_GetCachedImageIndex(c_szShell32Dll, iIcon, 0); _dwClass |= SHCF_ICON_DOCICON; // make _dwClass non-zero } // Shell_GetCachedImageIndex can return -1 for failure cases. We // dont want to or -1 in, so check to make sure the index is valid. if ((iImage & ~SHCF_ICON_INDEX) == 0) { // no higher bits set so its ok to or the index in _dwClass |= iImage; } } if (SUCCEEDED(hr)) CoTaskMemFree(pszIcon); } #define ASSOCELEM_GETBITS (ASSOCELEM_USER | ASSOCELEM_DEFAULT | ASSOCELEM_SYSTEM) BOOL _IsKnown(IAssociationArray *paa) { BOOL fRet = FALSE; CComPtr spenum; if (paa && SUCCEEDED(paa->EnumElements(ASSOCELEM_GETBITS, &spenum))) { CComPtr spae; ULONG c; fRet = S_OK == spenum->Next(1, &spae, &c); } return fRet; } void CFileSysItemString::_QueryClassFlags(IAssociationArray *paa) { // always hide extension for .{guid} junction points: // unless ShowSuperHidden() is on. since this means the user wants to see system stuff if (!ShowSuperHidden() && _GetFileCLSID(FSName(), NULL)) _dwClass = SHCF_NEVER_SHOW_EXT; else if (CFSFolder::_IsFolder(_pidf)) _dwClass = SHCF_ALWAYS_SHOW_EXT; else _dwClass = 0; if (_IsKnown(paa)) { // see what handlers exist if (SUCCEEDED(paa->QueryExists(ASSOCELEM_GETBITS, AQNS_SHELLEX_HANDLER, TEXT("IconHandler")))) _dwClass |= SHCF_HAS_ICONHANDLER; // check for browsability if (!(SHGetAppCompatFlags(ACF_DOCOBJECT) & ACF_DOCOBJECT)) { if (SUCCEEDED(paa->QueryExists(ASSOCELEM_GETBITS, AQN_NAMED_VALUE, TEXT("DocObject"))) || SUCCEEDED(paa->QueryExists(ASSOCELEM_GETBITS, AQN_NAMED_VALUE, TEXT("BrowseInPlace")))) _dwClass |= SHCF_IS_DOCOBJECT; } if (IsMemberOfCategory(paa, CATID_BrowsableShellExt)) _dwClass |= SHCF_IS_SHELLEXT; // get attributes if (SUCCEEDED(paa->QueryExists(ASSOCELEM_GETBITS, AQN_NAMED_VALUE, TEXT("IsShortcut")))) _dwClass |= SHCF_IS_LINK; if (SUCCEEDED(paa->QueryExists(ASSOCELEM_GETBITS, AQN_NAMED_VALUE, TEXT("AlwaysShowExt")))) _dwClass |= SHCF_ALWAYS_SHOW_EXT; if (SUCCEEDED(paa->QueryExists(ASSOCELEM_GETBITS, AQN_NAMED_VALUE, TEXT("NeverShowExt")))) _dwClass |= SHCF_NEVER_SHOW_EXT; // figure out what type of icon this type of file uses. if (_dwClass & SHCF_HAS_ICONHANDLER) { _dwClass |= SHCF_ICON_PERINSTANCE; } } else { // unknown type - pick defaults and get out. _dwClass |= SHCF_UNKNOWN | SHCF_ALWAYS_SHOW_EXT; } } CFSFolder * GetFSFolderFromShellFolder(IShellFolder *psf) { CFSFolder *pfs = NULL; if (psf) psf->QueryInterface(IID_INeedRealCFSFolder, (void **)&pfs); return pfs; } PERCEIVED GetPerceivedType(IShellFolder *psf, LPCITEMIDLIST pidl) { PERCEIVED gen = GEN_UNKNOWN; CFSFolder *pfsf = GetFSFolderFromShellFolder(psf); if (pfsf) { LPCIDFOLDER pidf = CFSFolder_IsValidID(pidl); if (pidf) { CFileSysItemString fsi(pidf); gen = fsi.PerceivedType(); } } return gen; } const struct { PERCEIVED gen; LPCWSTR psz; } c_rgPerceivedTypes[] = { {GEN_TEXT, L"text"}, {GEN_IMAGE, L"image"}, {GEN_AUDIO, L"audio"}, {GEN_VIDEO, L"video"}, {GEN_COMPRESSED, L"compressed"}, }; PERCEIVED CFileSysItemString::PerceivedType() { // look up the file type in the cache. PERCEIVED gen = LookupFilePerceivedType(Class()); if (gen == GEN_UNKNOWN) { WCHAR sz[40]; DWORD cb = sizeof(sz); if (NOERROR == SHGetValueW(HKEY_CLASSES_ROOT, Class(), L"PerceivedType", NULL, sz, &cb)) { gen = GEN_CUSTOM; for (int i = 0; i < ARRAYSIZE(c_rgPerceivedTypes); i++) { if (0 == StrCmpC(c_rgPerceivedTypes[i].psz, sz)) { gen = c_rgPerceivedTypes[i].gen; break; } } } else if (CFSFolder::_IsFolder(_pidf)) { gen = GEN_FOLDER; } else { gen = GEN_UNSPECIFIED; } AddFilePerceivedType(Class(), gen); } return gen; } BOOL _IsImageExt(PCWSTR psz); BOOL CFileSysItemString::IsShimgvwImage() { return _IsImageExt(Class()); } DWORD CFileSysItemString::_ClassFlags(IUnknown *punkAssoc, BOOL fNeedsIconBits) { // look up the file type in the cache. if (!_dwClass) _dwClass = LookupFileClass(Class()); if (_dwClass) { if (!fNeedsIconBits || (_dwClass & SHCF_ICON_INDEX) != SHCF_ICON_INDEX) return _dwClass; } IAssociationArray *paa; HRESULT hr; if (punkAssoc) hr = punkAssoc->QueryInterface(IID_PPV_ARG(IAssociationArray, &paa)); else hr = AssocCreate(NULL, FALSE, IID_PPV_ARG(IAssociationArray, &paa)); if (!_dwClass) _QueryClassFlags(paa); if (fNeedsIconBits && !(_dwClass & SHCF_ICON_PERINSTANCE)) _QueryIconIndex(paa); else { // set it to be not init'd _dwClass |= SHCF_ICON_INDEX; } if (SUCCEEDED(hr)) { paa->Release(); if (0 == _dwClass) { // If we hit this, the extension for this file type is incorrectly installed // and it will cause double clicking on such files to open the "Open With..." // file associatins dialog. // // IF YOU HIT THIS: // 1. Find the file type by checking szClass. // 2. Contact the person that installed that file type and have them fix // the install to have an icon and an associated program. TraceMsg(TF_WARNING, "_GetClassFlags() has detected an improperly registered class: '%s'", Class()); } } AddFileClass(Class(), _dwClass); return _dwClass; } // // this function checks for flags in desktop.ini // #define GFF_DEFAULT_TO_FS 0x0001 // the shell-xtension permits FS as the default where it cannot load #define GFF_ICON_FOR_ALL_FOLDERS 0x0002 // use the icon specified in the desktop.ini for all sub folders BOOL CFSFolder::_GetFolderFlags(LPCIDFOLDER pidf, UINT *prgfFlags) { TCHAR szPath[MAX_PATH]; *prgfFlags = 0; if (FAILED(_GetPathForItem(pidf, szPath))) return FALSE; if (PathAppend(szPath, c_szDesktopIni)) { if (GetPrivateProfileInt(STRINI_CLASSINFO, TEXT("DefaultToFS"), 1, szPath)) { *prgfFlags |= GFF_DEFAULT_TO_FS; } #if 0 if (GetPrivateProfileInt(STRINI_CLASSINFO, TEXT("SubFoldersUseIcon"), 1, szPath)) { *prgfFlags |= GFF_ICON_FOR_ALL_FOLDERS; } #endif } return TRUE; } // // This funtion retrieves the ICONPATh from desktop.ini file. // It takes a pidl as an input. // NOTE: There is code in SHDOCVW--ReadIconLocation that does almost the same thing // only that code looks in .URL files instead of desktop.ini BOOL CFSFolder::_GetFolderIconPath(LPCIDFOLDER pidf, LPTSTR pszIcon, int cchMax, UINT *pIndex) { TCHAR szPath[MAX_PATH], szIcon[MAX_PATH]; BOOL fSuccess = FALSE; UINT iIndex; if (pszIcon == NULL) { pszIcon = szIcon; cchMax = ARRAYSIZE(szPath); } if (pIndex == NULL) pIndex = &iIndex; *pIndex = _GetDefaultFolderIcon(); // Default the index to II_FOLDER (default folder icon) if (SUCCEEDED(_GetPathForItem(pidf, szPath))) { if (GetFolderString(szPath, _pszNetProvider, pszIcon, cchMax, SZ_CANBEUNICODE TEXT("IconFile"))) { // Fix the relative path PathCombine(pszIcon, szPath, pszIcon); fSuccess = PathFileExistsAndAttributes(pszIcon, NULL); if (fSuccess) { TCHAR szIndex[16]; if (GetFolderString(szPath, _pszNetProvider, szIndex, ARRAYSIZE(szIndex), TEXT("IconIndex"))) { StrToIntEx(szIndex, 0, (int *)pIndex); } } } } return fSuccess; } // IDList factory CFileSysItem::CFileSysItem(LPCIDFOLDER pidf) : _pidf(pidf), _pidp((PCIDPERSONALIZED)-1) { _pidfx = (PCIDFOLDEREX) ILFindHiddenIDOn((LPCITEMIDLIST)pidf, IDLHID_IDFOLDEREX, FALSE); if (_pidfx && _pidfx->hid.wVersion < IDFX_V1) _pidfx = NULL; } BOOL CFileSysItem::_IsPersonalized() { if (_pidp == (PCIDPERSONALIZED) -1) { _pidp = (PCIDPERSONALIZED) ILFindHiddenIDOn((LPCITEMIDLIST)_pidf, IDLHID_PERSONALIZED, FALSE); if (_pidp && 0 >= (signed short) _pidp->hid.wVersion) _pidp = NULL; } return _pidp != NULL; } CFileSysItemString::CFileSysItemString(LPCIDFOLDER pidf) : CFileSysItem(pidf), _pszFSName(NULL), _pszUIName(NULL), _pszClass(NULL), _dwClass(0), _fsin(FSINAME_NONE) { *_sz = 0; } LPCWSTR CFileSysItemString::FSName() { if (!_pszFSName) { if (!(_fsin & FSINAME_FS)) { LPCWSTR psz = MayCopyFSName(FALSE, _sz, ARRAYSIZE(_sz)); if (psz == _sz) _fsin = FSINAME_FS; else _pszFSName = psz; } } return _pszFSName ? _pszFSName : _sz; } LPCWSTR CFileSysItem::MayCopyFSName(BOOL fMustCopy, LPWSTR psz, DWORD cch) { if (_pidfx) { LPNWSTR pnsz = UASTROFFW(_pidfx, _pidfx->offNameW); // return back a pointer inside the pidfx // if we can... if (fMustCopy || ((INT_PTR)pnsz & 1)) { ualstrcpynW(psz, pnsz, cch); } else psz = (LPWSTR) pnsz; } else { if ((CFSFolder::_GetType(_pidf) & SHID_FS_UNICODE) == SHID_FS_UNICODE) { ualstrcpynW(psz, (LPCWSTR)_pidf->cFileName, cch); } else { MultiByteToWideChar(CP_ACP, 0, _pidf->cFileName, -1, psz, cch); } } return psz; } LPCSTR CFileSysItemString::AltName() { UINT cbName; if (_pidfx) { // we put the altname in cFileName cbName = 0; } else if ((CFSFolder::_GetType(_pidf) & SHID_FS_UNICODE) == SHID_FS_UNICODE) { cbName = (ualstrlenW((LPCWSTR)_pidf->cFileName) + 1) * sizeof(WCHAR); } else { cbName = lstrlenA(_pidf->cFileName) + 1; } return _pidf->cFileName + cbName; } LPCWSTR CFileSysItemString::UIName(CFSFolder *pfs) { if (!_pszUIName) { if (!(_fsin & FSINAME_UI)) { if (!_pidfx || !_LoadResource(pfs)) { if (!ShowExtension(pfs->_DefaultShowExt())) { // we need to have a buffer if (!(_fsin & FSINAME_FS)) MayCopyFSName(TRUE, _sz, ARRAYSIZE(_sz)); PathRemoveExtension(_sz); // lose the FSINAME_FS bit _fsin = FSINAME_UI; } else { // the FSName and the UIName are the same if (_sz == FSName()) { // the FSName and the UIName are the same // pidl is unaligned so the buffer gets double work _fsin = FSINAME_FSUI; } else { // and we are aligned so we can use the same name // directories are often this way. _pszUIName = _pszFSName; } } } } } return _pszUIName ? _pszUIName : _sz; } UINT UnicodeToAscii(LPCWSTR pwsz, LPSTR psz, UINT cch) { // always at least copy the NULL UINT cchRet = 1; while (cch-- && (*psz++ = (CHAR) *pwsz++)) { ASSERT(!(*pwsz & 0xff00)); cchRet++; } if (0 > (INT)cch) psz[cchRet - 1] = 0; return cchRet; } UINT AsciiToUnicode(LPCSTR psz, LPWSTR pwsz, UINT cch) { UINT cchRet = 1; while (cch-- && (*pwsz++ = (WCHAR) *psz++)) { cchRet++; } if (0 > (INT)cch) pwsz[cchRet - 1] = 0; return cchRet; } BOOL CFileSysItemString::_ResourceName(LPWSTR psz, DWORD cch, BOOL fIsMine) { BOOL fRet = FALSE; if (_IsPersonalized()) { int ids = _GetPersonalizedRes((int)_pidp->hid.wVersion, fIsMine); if (ids != -1) { wnsprintf(psz, cch, L"@shell32.dll,-%d", ids); fRet = TRUE; } } else if (_pidfx && _pidfx->offResourceA) { SHAnsiToUnicode(UASTROFFA(_pidfx, _pidfx->offResourceA), psz, cch); fRet = TRUE; } return fRet; } LPCWSTR CFileSysItemString::ResourceName() { if (!(_fsin & FSINAME_RESOURCE)) { if (!_ResourceName(_sz, ARRAYSIZE(_sz), FALSE)) *_sz = 0; } _fsin = FSINAME_RESOURCE; return _sz; } HRESULT CFileSysItemString::GetFindDataSimple(WIN32_FIND_DATAW *pfd) { ZeroMemory(pfd, sizeof(*pfd)); // Note that COFSFolder doesn't provide any times _but_ COFSFolder DosDateTimeToFileTime(_pidf->dateModified, _pidf->timeModified, &pfd->ftLastWriteTime); pfd->dwFileAttributes = _pidf->wAttrs; pfd->nFileSizeLow = _pidf->dwSize; StrCpyN(pfd->cFileName, FSName(), ARRAYSIZE(pfd->cFileName)); SHAnsiToUnicode(AltName(), pfd->cAlternateFileName, ARRAYSIZE(pfd->cAlternateFileName)); if (_pidfx) { DosDateTimeToFileTime(_pidfx->dsCreate.wDate, _pidfx->dsCreate.wTime, &pfd->ftCreationTime); DosDateTimeToFileTime(_pidfx->dsAccess.wDate, _pidfx->dsAccess.wTime, &pfd->ftLastAccessTime); } return S_OK; } HRESULT CFileSysItemString::GetFindData(WIN32_FIND_DATAW *pfd) { HRESULT hr; // if its a simple ID, there's no data in it if (CFSFolder::_IsReal(_pidf)) { hr = GetFindDataSimple(pfd); } else { ZeroMemory(pfd, sizeof(*pfd)); hr = E_INVALIDARG; } return hr; } typedef struct { int csidl; int idsMine; int idsTheirs; } PERSONALIZEDNAME; int CFileSysItemString::_GetPersonalizedRes(int csidl, BOOL fIsMine) { static const PERSONALIZEDNAME s_pnames[] = { { CSIDL_PERSONAL, -1, IDS_LOCALGDN_FLD_THEIRDOCUMENTS}, { CSIDL_MYPICTURES, IDS_LOCALGDN_FLD_MYPICTURES, IDS_LOCALGDN_FLD_THEIRPICTURES}, { CSIDL_MYMUSIC, IDS_LOCALGDN_FLD_MYMUSIC, IDS_LOCALGDN_FLD_THEIRMUSIC}, { CSIDL_MYVIDEO, IDS_LOCALGDN_FLD_MYVIDEOS, IDS_LOCALGDN_FLD_THEIRVIDEOS}, }; for (int i = 0; i < ARRAYSIZE(s_pnames); i++) { if (s_pnames[i].csidl == csidl) { return fIsMine ? s_pnames[i].idsMine : s_pnames[i].idsTheirs; } } AssertMsg(FALSE, TEXT("Personalized Resource not in table")); return -1; } TRIBIT CFileSysItem::_IsMine(CFSFolder *pfs) { TRIBIT tb = TRIBIT_UNDEFINED; if (_IsPersonalized()) { WCHAR szPath[MAX_PATH]; if (SUCCEEDED(SHGetFolderPath(NULL, (int)_pidp->hid.wVersion | CSIDL_FLAG_DONT_VERIFY, NULL, SHGFP_TYPE_CURRENT, szPath))) { WCHAR szThis[MAX_PATH]; if (SUCCEEDED(pfs->_GetPathForItem(_pidf, szThis))) { // if they match then its ours // if they dont then it still personalized (theirs) if (0 == StrCmpI(szThis, szPath)) tb = TRIBIT_TRUE; else { tb = TRIBIT_FALSE; } } } } return tb; } void CFileSysItemString::_FormatTheirs(LPCWSTR pszFormat) { WCHAR szOwner[UNLEN]; ualstrcpynW(szOwner, _pidp->szUserName, ARRAYSIZE(szOwner)); if (!IsOS(OS_DOMAINMEMBER)) { // maybe we should do caching here??? // pfs->GetUserName(szOwner, szOwner, ARRAYSIZE(szOwner)); USER_INFO_10 *pui; if (NERR_Success == NetUserGetInfo(NULL, szOwner, 10, (LPBYTE*)&pui)) { LPTSTR pszName = (*pui->usri10_full_name) ? pui->usri10_full_name: pui->usri10_name; if (*pszName) { StrCpyN(szOwner, pszName, ARRAYSIZE(szOwner)); } NetApiBufferFree(pui); } } wnsprintf(_sz, ARRAYSIZE(_sz), pszFormat, szOwner); } BOOL CFileSysItemString::_LoadResource(CFSFolder *pfs) { WCHAR szResource[MAX_PATH]; BOOL fRet = FALSE; TRIBIT tbIsMine = _IsMine(pfs); if (_ResourceName(szResource, ARRAYSIZE(szResource), tbIsMine == TRIBIT_TRUE)) { DWORD cb = sizeof(_sz); // first check the registry for overrides if (S_OK == SKGetValueW(SHELLKEY_HKCU_SHELL, L"LocalizedResourceName", szResource, NULL, _sz, &cb) && *_sz) { fRet = TRUE; } else if (szResource[0] == TEXT('@')) { // it does caching for us fRet = SUCCEEDED(SHLoadIndirectString(szResource, _sz, ARRAYSIZE(_sz), NULL)); // If the call fails, this means that the // localized string belongs to a DLL that has been uninstalled. // Just return the failure code so we act as if the MUI string // isn't there. (Don't show the user "@DLLNAME.DLL,-5" as the // name!) if (fRet && tbIsMine == TRIBIT_FALSE) { // reuse szResource as the format string StrCpyN(szResource, _sz, ARRAYSIZE(szResource)); _FormatTheirs(szResource); } } } if (fRet) _fsin = FSINAME_UI; ASSERT(!_fsin || *_sz); return fRet; } BOOL CFileSysItem::CantRename(CFSFolder *pfs) { // BOOL fRest = SHRestricted(REST_NORENAMELOCALIZED); if (_IsPersonalized()) { if (!_IsMine(pfs)) return TRUE; // return fRest; } else if (_pidfx && _pidfx->offResourceA) { // return fRest; } return FALSE; } UINT _CopyResource(LPWSTR pszSrc, LPSTR pszRes, UINT cchRes) { ASSERT(*pszSrc == L'@'); LPWSTR pszS32 = StrStrIW(pszSrc, L"shell32.dll"); if (pszS32) { *(--pszS32) = L'@'; pszSrc = pszS32; } return SHUnicodeToAnsi(pszSrc, pszRes, cchRes); } UINT CFSFolder::_GetItemExStrings(LPCIDFOLDER pidfSimpleParent, const WIN32_FIND_DATA *pfd, EXSTRINGS *pxs) { UINT cbRet = 0; TCHAR szTemp[MAX_PATH]; if ((pfd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) && (pfd->dwFileAttributes & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY))) { if (SUCCEEDED(_GetPathForItem(pidfSimpleParent, szTemp))) { PathAppend(szTemp, pfd->cFileName); if (GetFolderStringEx(szTemp, _pszNetProvider, L"DeleteOnCopy", SZ_CANBEUNICODE TEXT("Owner"), pxs->idp.szUserName, ARRAYSIZE(pxs->idp.szUserName))) { pxs->idp.hid.cb = sizeof(pxs->idp.hid) + CbFromCchW(lstrlenW(pxs->idp.szUserName) + 1); pxs->idp.hid.id = IDLHID_PERSONALIZED; WCHAR szFile[MAX_PATH]; if (GetFolderStringEx(szTemp, _pszNetProvider, L"DeleteOnCopy", SZ_CANBEUNICODE TEXT("PersonalizedName"), szFile, ARRAYSIZE(szFile))) { if (0 == StrCmpI(pfd->cFileName, szFile)) pxs->idp.hid.wVersion = (WORD) GetFolderInt(szTemp, _pszNetProvider, L"DeleteOnCopy", TEXT("Personalized"), -1); } } else if (GetFolderString(szTemp, _pszNetProvider, szTemp, ARRAYSIZE(szTemp), TEXT("LocalizedResourceName"))) { pxs->cbResource = _CopyResource(szTemp, pxs->szResource, ARRAYSIZE(pxs->szResource)); cbRet += pxs->cbResource; } } } else if (!pidfSimpleParent && _IsSelfSystemFolder()) { if (_HasLocalizedFileNames() && SUCCEEDED(_GetPath(szTemp))) { if (GetFolderStringEx(szTemp, _pszNetProvider, TEXT("LocalizedFileNames"), pfd->cFileName, szTemp, ARRAYSIZE(szTemp))) { pxs->cbResource = _CopyResource(szTemp, pxs->szResource, ARRAYSIZE(pxs->szResource)); cbRet += pxs->cbResource; } } } return cbRet; } BOOL _PrepIDFName(const WIN32_FIND_DATA *pfd, LPSTR psz, DWORD cch, const void **ppvName, UINT *pcbName) { // the normal case: // the altname should only not be filled in // in the case of the name being a shortname (ASCII) LPCWSTR pwsz = *pfd->cAlternateFileName && !(SHGetAppCompatFlags(ACF_FORCELFNIDLIST) & ACF_FORCELFNIDLIST) ? pfd->cAlternateFileName : pfd->cFileName; if (DoesStringRoundTrip(pwsz, psz, cch)) { *pcbName = lstrlenA(psz) + 1; *ppvName = psz; } else { *pcbName = CbFromCchW(lstrlenW(pwsz) + 1); *ppvName = pfd->cFileName; } return *ppvName != psz; } HRESULT CFSFolder::_CreateIDList(const WIN32_FIND_DATA *pfd, LPCIDFOLDER pidfSimpleParent, LPITEMIDLIST *ppidl) { // for the idf CHAR szNameIDF[MAX_PATH]; UINT cbNameIDF; const void *pvNameIDF; BOOL fNeedsUnicode = _PrepIDFName(pfd, szNameIDF, ARRAYSIZE(szNameIDF), &pvNameIDF, &cbNameIDF); UINT cbIDF = FIELD_OFFSET(IDFOLDER, cFileName) + cbNameIDF; ASSERT(*((char *)pvNameIDF)); // for the idfx UINT cbNameIDFX = CbFromCchW(lstrlenW(pfd->cFileName) + 1); EXSTRINGS xs = {0}; UINT cbIDFX = sizeof(IDFOLDEREX) + cbNameIDFX + _GetItemExStrings(pidfSimpleParent, pfd, &xs); // try to align these babies cbIDF = ROUNDUP(cbIDF, 2); cbIDFX = ROUNDUP(cbIDFX, 2); // ILCreateWithHidden() fills in the cb values LPIDFOLDER pidf = (LPIDFOLDER)ILCreateWithHidden(cbIDF, cbIDFX); if (pidf) { // initialize the idf // tag files > 4G so we can do a full find first when we need to know the real size pidf->dwSize = pfd->nFileSizeHigh ? 0xFFFFFFFF : pfd->nFileSizeLow; pidf->wAttrs = (WORD)pfd->dwFileAttributes; // Since the idf entry is not aligned, we cannot just send the address // of one of its members blindly into FileTimeToDosDateTime. WORD date, time; if (FileTimeToDosDateTime(&pfd->ftLastWriteTime, &date, &time)) { *((UNALIGNED WORD *)&pidf->dateModified) = date; *((UNALIGNED WORD *)&pidf->timeModified) = time; } // copy the short name memcpy(pidf->cFileName, pvNameIDF, cbNameIDF); // setup bFlags pidf->bFlags = pfd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ? SHID_FS_DIRECTORY : SHID_FS_FILE; if (CSIDL_COMMON_DESKTOPDIRECTORY == _csidlTrack) pidf->bFlags |= SHID_FS_COMMONITEM; if (fNeedsUnicode) pidf->bFlags |= SHID_FS_UNICODE; // now initialize the hidden idfx PIDFOLDEREX pidfx = (PIDFOLDEREX) _ILSkip((LPITEMIDLIST)pidf, cbIDF); pidfx->hid.id = IDLHID_IDFOLDEREX; pidfx->hid.wVersion = IDFX_CV; if (FileTimeToDosDateTime(&pfd->ftCreationTime, &date, &time)) { pidfx->dsCreate.wDate = date; pidfx->dsCreate.wTime = time; } if (FileTimeToDosDateTime(&pfd->ftLastAccessTime, &date, &time)) { pidfx->dsAccess.wDate = date; pidfx->dsAccess.wTime = time; } // append the strings pidfx->offNameW = (USHORT) sizeof(IDFOLDEREX); ualstrcpyW(UASTROFFW(pidfx, pidfx->offNameW), pfd->cFileName); USHORT offNext = (USHORT) sizeof(IDFOLDEREX) + cbNameIDFX; if (xs.cbResource) { pidfx->offResourceA = offNext; ualstrcpyA(UASTROFFA(pidfx, pidfx->offResourceA), xs.szResource); // offNext += (USHORT) xs.cbResource; if we have more offsets... } pidf = _MarkAsJunction(pidfSimpleParent, pidf, pfd->cFileName); if (pidf && xs.idp.hid.cb) pidf = (LPIDFOLDER) ILAppendHiddenID((LPITEMIDLIST)pidf, &xs.idp.hid); } *ppidl = (LPITEMIDLIST)pidf; return *ppidl != NULL ? S_OK : E_OUTOFMEMORY; } BOOL _ValidPathSegment(LPCTSTR pszSegment) { if (*pszSegment && !PathIsDotOrDotDot(pszSegment)) { for (LPCTSTR psz = pszSegment; *psz; psz = CharNext(psz)) { if (!PathIsValidChar(*psz, PIVC_LFN_NAME)) return FALSE; } return TRUE; } return FALSE; } // used to parse up file path like strings: // "folder\folder\file.txt" // "file.txt" // // in/out: // *ppszIn in: pointer to start of the buffer, // output: advanced to next location, NULL on last segment // out: // *pszSegment NULL if nothing left // // returns: // S_OK got a segment // S_FALSE loop done, *pszSegment emtpy // E_INVALIDARG invalid input "", "\foo", "\\foo", "foo\\bar", "?<>*" chars in seg HRESULT _NextSegment(LPCWSTR *ppszIn, LPTSTR pszSegment, UINT cchSegment, BOOL bValidate) { HRESULT hr; *pszSegment = 0; if (*ppszIn) { // WARNING! Do not use StrPBrkW(*ppszIn, L"\\/"), because // Trident passes fully-qualified URLs to // SHGetFileInfo(USEFILEATTRIBUTES) and relies on the fact that // we won't choke on the embedded "//" in "http://". LPWSTR pszSlash = StrChrW(*ppszIn, L'\\'); if (pszSlash) { if (pszSlash > *ppszIn) // make sure well formed (no dbl slashes) { OleStrToStrN(pszSegment, cchSegment, *ppszIn, (int)(pszSlash - *ppszIn)); // make sure that there is another segment to return if (!*(++pszSlash)) pszSlash = NULL; hr = S_OK; } else { pszSlash = NULL; hr = E_INVALIDARG; // bad input } } else { SHUnicodeToTChar(*ppszIn, pszSegment, cchSegment); hr = S_OK; } *ppszIn = pszSlash; if (hr == S_OK && bValidate && !_ValidPathSegment(pszSegment)) { *pszSegment = 0; hr = E_INVALIDARG; } } else hr = S_FALSE; // done with loop return hr; } // this makes a fake wfd and then uses the normal // FillIDFolder as if it were a real found path. HRESULT CFSFolder::_ParseSimple(LPCWSTR pszPath, const WIN32_FIND_DATA *pfdLast, LPITEMIDLIST *ppidl) { WIN32_FIND_DATA wfd = {0}; HRESULT hr = S_OK; *ppidl = NULL; ASSERT(*pszPath); while (SUCCEEDED(hr) && (S_OK == (hr = _NextSegment((LPCWSTR *)&pszPath, wfd.cFileName, ARRAYSIZE(wfd.cFileName), FALSE)))) { LPITEMIDLIST pidl; if (pszPath) { // internal componets must be folders wfd.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY; } else { // last segment takes the find data from that passed in // copy everything except the cFileName field memcpy(&wfd, pfdLast, FIELD_OFFSET(WIN32_FIND_DATA, cFileName)); lstrcpyn(wfd.cAlternateFileName, pfdLast->cAlternateFileName, ARRAYSIZE(wfd.cAlternateFileName)); } hr = _CreateIDList(&wfd, (LPCIDFOLDER)*ppidl, &pidl); if (SUCCEEDED(hr)) hr = SHILAppend(pidl, ppidl); } if (FAILED(hr)) { if (*ppidl) { ILFree(*ppidl); *ppidl = NULL; } } else hr = S_OK; // pin all success to S_OK return hr; } BOOL IsAllWhiteSpace(LPCTSTR pszString) { while (*pszString) { if ((TEXT(' ') == *pszString) || (TEXT('\t') == *pszString)) { pszString++; // keep walking the string } else { return FALSE; // something other than a space or tab, done } } return TRUE; // made it through the loop, just spaces or tabs in this string } HRESULT _CheckPortName(LPCTSTR pszName) { if (PathIsInvalid(pszName)) return HRESULT_FROM_WIN32(ERROR_BAD_DEVICE); else return S_OK; } class CFindFirstWithTimeout { public: CFindFirstWithTimeout(LPCTSTR pszPath, DWORD dwTicksToAllow); HRESULT FindFirstWithTimeout(WIN32_FIND_DATA *pfd); ULONG AddRef(); ULONG Release(); private: static DWORD WINAPI _FindFistThreadProc(void *pv); LONG _cRef; DWORD _dwTicksToAllow; TCHAR _szPath[MAX_PATH]; WIN32_FIND_DATA _fd; }; CFindFirstWithTimeout::CFindFirstWithTimeout(LPCTSTR pszPath, DWORD dwTicksToAllow) : _cRef(1), _dwTicksToAllow(dwTicksToAllow) { lstrcpyn(_szPath, pszPath, ARRAYSIZE(_szPath)); } ULONG CFindFirstWithTimeout::AddRef() { return InterlockedIncrement(&_cRef); } ULONG CFindFirstWithTimeout::Release() { if (InterlockedDecrement(&_cRef)) return _cRef; delete this; return 0; } DWORD CFindFirstWithTimeout::_FindFistThreadProc(void *pv) { CFindFirstWithTimeout *pffwt = (CFindFirstWithTimeout *)pv; HRESULT hr = SHFindFirstFileRetry(NULL, NULL, pffwt->_szPath, &pffwt->_fd, NULL, SHPPFW_NONE); pffwt->Release(); return hr; // retrieved via GetExitCodeThread() } HRESULT CFindFirstWithTimeout::FindFirstWithTimeout(WIN32_FIND_DATA *pfd) { HRESULT hr; AddRef(); // ref for the thread DWORD dwID; HANDLE hThread = CreateThread(NULL, 0, _FindFistThreadProc, this, 0, &dwID); if (hThread) { // assume timeout... hr = HRESULT_FROM_WIN32(ERROR_TIMEOUT); // timeout return value if (WAIT_OBJECT_0 == WaitForSingleObject(hThread, _dwTicksToAllow)) { // thread finished with an HRESULT for us DWORD dw; if (GetExitCodeThread(hThread, &dw)) { *pfd = _fd; hr = dw; // HRESULT returned by _FindFistThreadProc } } CloseHandle(hThread); } else { hr = E_OUTOFMEMORY; Release(); // thread create failed, remove that ref } return hr; } HRESULT SHFindFirstFileWithTimeout(LPCTSTR pszPath, DWORD dwTicksToAllow, WIN32_FIND_DATA *pfd) { HRESULT hr; CFindFirstWithTimeout *pffwt = new CFindFirstWithTimeout(pszPath, dwTicksToAllow); if (pffwt) { hr = pffwt->FindFirstWithTimeout(pfd); pffwt->Release(); } else { hr = E_OUTOFMEMORY; } return hr; } HRESULT CFSFolder::_FindDataFromName(LPCTSTR pszName, DWORD dwAttribs, IBindCtx *pbc, WIN32_FIND_DATA **ppfd) { *ppfd = NULL; HRESULT hr = _CheckPortName(pszName); if (SUCCEEDED(hr)) { hr = SHLocalAlloc(sizeof(**ppfd), ppfd); if (SUCCEEDED(hr)) { if (-1 == dwAttribs) { TCHAR szPath[MAX_PATH]; hr = _GetPath(szPath); if (SUCCEEDED(hr)) { PathAppend(szPath, pszName); DWORD dwTicksToAllow; if (SUCCEEDED(BindCtx_GetTimeoutDelta(pbc, &dwTicksToAllow)) && PathIsNetworkPath(szPath)) { hr = SHFindFirstFileWithTimeout(szPath, dwTicksToAllow, *ppfd); } else { hr = SHFindFirstFileRetry(NULL, NULL, szPath, *ppfd, NULL, SHPPFW_NONE); } } } else { // make a simple one up StrCpyN((*ppfd)->cFileName, pszName, ARRAYSIZE((*ppfd)->cFileName)); (*ppfd)->dwFileAttributes = dwAttribs; } if (FAILED(hr)) { LocalFree(*ppfd); *ppfd = NULL; } } } ASSERT(SUCCEEDED(hr) ? NULL != *ppfd : NULL == *ppfd); return hr; } // // This function returns a relative pidl for the specified file/folder // HRESULT CFSFolder::_CreateIDListFromName(LPCTSTR pszName, DWORD dwAttribs, IBindCtx *pbc, LPITEMIDLIST *ppidl) { WIN32_FIND_DATA *pfd; HRESULT hr = _FindDataFromName(pszName, dwAttribs, pbc, &pfd); if (SUCCEEDED(hr)) { hr = _CreateIDList(pfd, NULL, ppidl); LocalFree(pfd); } else *ppidl = NULL; return hr; } // used to detect if a name is a folder. this is used in the case that the // security for this folders parent is set so you can't enum it's contents BOOL CFSFolder::_CanSeeInThere(LPCTSTR pszName) { TCHAR szPath[MAX_PATH]; if (SUCCEEDED(_GetPath(szPath))) { HANDLE hfind; WIN32_FIND_DATA fd; PathAppend(szPath, pszName); PathAppend(szPath, TEXT("*.*")); hfind = FindFirstFile(szPath, &fd); if (hfind != INVALID_HANDLE_VALUE) FindClose(hfind); return hfind != INVALID_HANDLE_VALUE; } return FALSE; } HRESULT CFSFolder::v_InternalQueryInterface(REFIID riid, void **ppv) { static const QITAB qit[] = { QITABENTMULTI(CFSFolder, IShellFolder, IShellFolder2), QITABENT(CFSFolder, IShellFolder2), QITABENT(CFSFolder, IShellIconOverlay), QITABENT(CFSFolder, IShellIcon), QITABENTMULTI(CFSFolder, IPersist, IPersistFolder3), QITABENTMULTI(CFSFolder, IPersistFolder, IPersistFolder3), QITABENTMULTI(CFSFolder, IPersistFolder2, IPersistFolder3), QITABENT(CFSFolder, IPersistFolder3), QITABENT(CFSFolder, IStorage), QITABENT(CFSFolder, IPropertySetStorage), QITABENT(CFSFolder, IItemNameLimits), QITABENT(CFSFolder, IContextMenuCB), QITABENT(CFSFolder, ISetFolderEnumRestriction), QITABENT(CFSFolder, IOleCommandTarget), { 0 }, }; HRESULT hr = QISearch(this, qit, riid, ppv); if (FAILED(hr)) { if (IsEqualIID(IID_INeedRealCFSFolder, riid)) { *ppv = this; // not ref counted hr = S_OK; } else if (IsEqualIID(riid, IID_IPersistFreeThreadedObject)) { if (_GetInner() == _GetOuter()) // not aggregated { hr = QueryInterface(IID_IPersist, ppv); } else { hr = E_NOINTERFACE; } } } return hr; } // briefcase and file system folder call to reset data HRESULT CFSFolder::_Reset() { _DestroyColHandlers(); if (_pidl) { ILFree(_pidl); _pidl = NULL; } if (_pidlTarget) { ILFree(_pidlTarget); _pidlTarget = NULL; } if (_pszPath) { LocalFree(_pszPath); _pszPath = NULL; } if (_pszNetProvider) { LocalFree(_pszNetProvider); _pszNetProvider = NULL; } _csidl = -1; _dwAttributes = -1; _csidlTrack = -1; ATOMICRELEASE(_pstg); return S_OK; } #define INVALID_PATHSPEED (-100) CFSFolder::CFSFolder(IUnknown *punkOuter) : CAggregatedUnknown(punkOuter) { _csidl = -1; _iFolderIcon = -1; _dwAttributes = -1; _csidlTrack = -1; _nFolderType = FVCBFT_DOCUMENTS; _bSlowPath = INVALID_PATHSPEED; // some non-common value // Note: BOOL is not bool _tbOfflineCSC = TRIBIT_UNDEFINED; DllAddRef(); } CFSFolder::~CFSFolder() { _Reset(); DllRelease(); } // we need to fail relative type paths since we use PathCombine // and we don't want that and the Win32 APIs to give us relative path behavior // ShellExecute() depends on this so it falls back and resolves the relative paths itself HRESULT CFSFolder::ParseDisplayName(HWND hwnd, IBindCtx *pbc, WCHAR *pszName, ULONG *pchEaten, LPITEMIDLIST *ppidl, DWORD *pdwAttributes) { HRESULT hr; WIN32_FIND_DATA *pfd; if (!ppidl) return E_INVALIDARG; *ppidl = NULL; // assume error if (pszName == NULL) return E_INVALIDARG; if (S_OK == SHIsFileSysBindCtx(pbc, &pfd)) { hr = _ParseSimple(pszName, pfd, ppidl); if (SUCCEEDED(hr) && pdwAttributes && *pdwAttributes) { // while strictly not a legit thing to do here, we // pass the last IDList because 1) this is a simple IDList // 2) we hope that callers don't ask for bits that // require a full path to be valid inside the impl of // ::GetAttributesOf() LPCITEMIDLIST pidlLast = ILFindLastID(*ppidl); GetAttributesOf(1, &pidlLast, pdwAttributes); } LocalFree(pfd); } else { DWORD cchNext = lstrlen(pszName) + 1; WCHAR *pszNext = (WCHAR *)alloca(CbFromCchW(cchNext)); hr = _NextSegment((LPCWSTR *)&pszName, pszNext, cchNext, TRUE); if (SUCCEEDED(hr)) { hr = _CreateIDListFromName(pszNext, -1, pbc, ppidl); if (hr == HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED)) { // security "List folder contents" may be disabled for // this items parent. so see if this is really there if (pszName || _CanSeeInThere(pszNext)) { hr = _CreateIDListFromName(pszNext, FILE_ATTRIBUTE_DIRECTORY, pbc, ppidl); } } else if (((hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)) || (hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND))) && (pszName == NULL) && (BindCtx_GetMode(pbc, 0) & STGM_CREATE) && !_fDontForceCreate) { // create a pidl to something that doesnt exist. hr = _CreateIDListFromName(pszNext, FILE_ATTRIBUTE_NORMAL, pbc, ppidl); } if (SUCCEEDED(hr)) { if (pszName) // more stuff to parse? { IShellFolder *psfFolder; hr = BindToObject(*ppidl, pbc, IID_PPV_ARG(IShellFolder, &psfFolder)); if (SUCCEEDED(hr)) { ULONG chEaten; LPITEMIDLIST pidlNext; hr = psfFolder->ParseDisplayName(hwnd, pbc, pszName, &chEaten, &pidlNext, pdwAttributes); if (SUCCEEDED(hr)) { hr = SHILAppend(pidlNext, ppidl); } psfFolder->Release(); } } else { if (pdwAttributes && *pdwAttributes) GetAttributesOf(1, (LPCITEMIDLIST *)ppidl, pdwAttributes); } } } } if (FAILED(hr) && *ppidl) { // This is needed if psfFolder->ParseDisplayName() or BindToObject() // fails because the pidl is already allocated. ILFree(*ppidl); *ppidl = NULL; } ASSERT(SUCCEEDED(hr) ? (*ppidl != NULL) : (*ppidl == NULL)); // display this only as a warning, this can get hit during mergfldr or IStorage::Create probes if (FAILED(hr)) TraceMsg(TF_WARNING, "CFSFolder::ParseDisplayName(), hr:%x %ls", hr, pszName); return hr; } STDAPI InitFileFolderClassNames(void) { if (g_szFileTemplate[0] == 0) // test last one to avoid race { LoadString(HINST_THISDLL, IDS_FOLDERTYPENAME, g_szFolderTypeName, ARRAYSIZE(g_szFolderTypeName)); LoadString(HINST_THISDLL, IDS_FILETYPENAME, g_szFileTypeName, ARRAYSIZE(g_szFileTypeName)); LoadString(HINST_THISDLL, IDS_EXTTYPETEMPLATE, g_szFileTemplate, ARRAYSIZE(g_szFileTemplate)); } return S_OK; } HRESULT CFSFolder::EnumObjects(HWND hwnd, DWORD grfFlags, IEnumIDList **ppenum) { InitFileFolderClassNames(); grfFlags |= _dwEnumRequired; grfFlags &= ~_dwEnumForbidden; return CFSFolder_CreateEnum(this, hwnd, grfFlags, ppenum); } HRESULT CFSFolder::BindToObject(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppv) { // MIL 117282 - Enroute Imaging QuickStitch depends on pre-Jan'97 behavior of us // *not* nulling ppv out on !_IsValidID(pidl). (They pass in a perfectly valid // IShellFolder* interfacing asking for IID_IShellFolder on the empty PIDL.) // if (!(SHGetAppCompatFlags(ACF_WIN95BINDTOOBJECT) & ACF_WIN95BINDTOOBJECT)) *ppv = NULL; HRESULT hr; LPCIDFOLDER pidf = _IsValidID(pidl); if (pidf) { LPCITEMIDLIST pidlRight; LPIDFOLDER pidfBind; hr = _GetJunctionForBind(pidf, &pidfBind, &pidlRight); if (SUCCEEDED(hr)) { if (hr == S_OK) { IShellFolder *psfJunction; hr = _Bind(pbc, pidfBind, IID_PPV_ARG(IShellFolder, &psfJunction)); if (SUCCEEDED(hr)) { // now bind to the stuff below the junction point hr = psfJunction->BindToObject(pidlRight, pbc, riid, ppv); psfJunction->Release(); } ILFree((LPITEMIDLIST)pidfBind); } else { ASSERT(pidfBind == NULL); hr = _Bind(pbc, pidf, riid, ppv); } } } else { hr = E_INVALIDARG; TraceMsg(TF_WARNING, "CFSFolder::BindToObject(), hr:%x bad PIDL %s", hr, DumpPidl(pidl)); } return hr; } HRESULT CFSFolder::BindToStorage(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppv) { return BindToObject(pidl, pbc, riid, ppv); } HRESULT CFSFolder::_CheckDriveRestriction(HWND hwnd, REFIID riid) { HRESULT hr = S_OK; DWORD dwRest = SHRestricted(REST_NOVIEWONDRIVE); if (dwRest) { TCHAR szPath[MAX_PATH]; hr = _GetPath(szPath); if (SUCCEEDED(hr)) { int iDrive = PathGetDriveNumber(szPath); if (iDrive != -1) { // is the drive restricted if (dwRest & (1 << iDrive)) { // don't show the error message on droptarget -- just fail silently if (hwnd && !IsEqualIID(riid, IID_IDropTarget)) { ShellMessageBox(HINST_THISDLL, hwnd, MAKEINTRESOURCE(IDS_RESTRICTIONS), MAKEINTRESOURCE(IDS_RESTRICTIONSTITLE), MB_OK | MB_ICONSTOP); hr = HRESULT_FROM_WIN32(ERROR_CANCELLED); // user saw the error } else hr = E_ACCESSDENIED; } } } } return hr; } HRESULT CFSFolder::_CreateUIHandler(REFIID riid, void **ppv) { HRESULT hr; // Cache the view CLSID if not cached. if (!_fCachedCLSID) { if (_IsSelfSystemFolder()) { TCHAR szPath[MAX_PATH]; if (SUCCEEDED(_GetPath(szPath))) _fHasCLSID = GetFolderGUID(szPath, _pszNetProvider, &_clsidView, TEXT("UICLSID")); _fCachedCLSID = TRUE; } } // Use the handler if it exists if (_fHasCLSID) { IPersistFolder *ppf; hr = SHExtCoCreateInstance(NULL, &_clsidView, NULL, IID_PPV_ARG(IPersistFolder, &ppf)); if (SUCCEEDED(hr)) { hr = ppf->Initialize(_pidl); if (FAILED(hr) && _pidlTarget) { // It may have failed because the _pidl is an alias (not a file folder). if so try // again with _pidlTarget (that will be a file system folder) // this was required for the Fonts FolderShortcut in the ControlPanel (stephstm) hr = ppf->Initialize(_pidlTarget); } if (SUCCEEDED(hr)) hr = ppf->QueryInterface(riid, ppv); ppf->Release(); } } else hr = E_FAIL; // no handler return hr; } HRESULT CFSFolder::CreateViewObject(HWND hwnd, REFIID riid, void **ppv) { HRESULT hr; *ppv = NULL; if (IsEqualIID(riid, IID_IShellView) || IsEqualIID(riid, IID_IDropTarget)) { hr = _CheckDriveRestriction(hwnd, riid); if (SUCCEEDED(hr)) { hr = _CreateUIHandler(riid, ppv); if (FAILED(hr)) { if (IsEqualIID(riid, IID_IDropTarget)) { hr = CFSDropTarget_CreateInstance(this, hwnd, (IDropTarget **)ppv); } else { SFV_CREATE csfv = { sizeof(csfv), 0 }; hr = QueryInterface(IID_PPV_ARG(IShellFolder, &csfv.pshf)); if (SUCCEEDED(hr)) { CFSFolderCallback_Create(this, &csfv.psfvcb); hr = SHCreateShellFolderView(&csfv, (IShellView **)ppv); if (csfv.psfvcb) csfv.psfvcb->Release(); csfv.pshf->Release(); } } } } } else if (IsEqualIID(riid, IID_IContextMenu)) { // do background menu. IShellFolder *psfToPass; // May be an Aggregate... hr = QueryInterface(IID_PPV_ARG(IShellFolder, &psfToPass)); if (SUCCEEDED(hr)) { LPCITEMIDLIST pidlMenuTarget = (_pidlTarget ? _pidlTarget : _pidl); HKEY hkNoFiles; RegOpenKey(HKEY_CLASSES_ROOT, TEXT("Directory\\Background"), &hkNoFiles); IContextMenuCB *pcmcb = new CDefBackgroundMenuCB(pidlMenuTarget); if (pcmcb) { hr = CDefFolderMenu_Create2Ex(pidlMenuTarget, hwnd, 0, NULL, psfToPass, pcmcb, 1, &hkNoFiles, (IContextMenu **)ppv); pcmcb->Release(); } psfToPass->Release(); if (hkNoFiles) // CDefFolderMenu_Create can handle NULL ok RegCloseKey(hkNoFiles); } } else if (IsEqualIID(riid, IID_ICategoryProvider)) { HKEY hk = NULL; RegOpenKey(HKEY_CLASSES_ROOT, TEXT("Directory\\shellex\\Category"), &hk); hr = CCategoryProvider_Create(NULL, NULL, hk, NULL, this, riid, ppv); if (hk) RegCloseKey(hk); } else { ASSERT(*ppv == NULL); hr = E_NOINTERFACE; } return hr; } #define LOGICALXOR(a, b) (((a) && !(b)) || (!(a) && (b))) HRESULT CFSFolder::_CompareNames(LPCIDFOLDER pidf1, LPCIDFOLDER pidf2, BOOL fCaseSensitive, BOOL fCanonical) { CFileSysItemString fsi1(pidf1), fsi2(pidf2); int iRet = StrCmpICW(fsi1.FSName(), fsi2.FSName()); if (iRet) { // // additional check for identity using the 8.3 or AltName() // if we are then the identity compare is better based off // the AltName() which should be the same regardless of // platform or CP. // if (LOGICALXOR(fsi1.IsLegacy(), fsi2.IsLegacy())) { if (lstrcmpiA(fsi1.AltName(), fsi2.AltName()) == 0) iRet = 0; } if (iRet && !fCanonical) { // they are definitely not the same item // Sort it based on the primary (long) name -- ignore case. int iUI = StrCmpLogicalRestricted(fsi1.UIName(this), fsi2.UIName(this)); // if they are the same we might want case sensitive instead if (iUI == 0 && fCaseSensitive) { iUI = ustrcmp(fsi1.UIName(this), fsi2.UIName(this)); } if (iUI) iRet = iUI; } } return ResultFromShort((short)iRet); } HRESULT CFSFolder::_CompareFileTypes(LPCIDFOLDER pidf1, LPCIDFOLDER pidf2) { short result; ENTERCRITICAL; LPCTSTR psz1 = _GetTypeName(pidf1); LPCTSTR psz2 = _GetTypeName(pidf2); if (psz1 != psz2) result = (short) ustrcmpi(psz1, psz2); else result = 0; LEAVECRITICAL; return ResultFromShort(result); } HRESULT CFSFolder::_CompareModifiedDate(LPCIDFOLDER pidf1, LPCIDFOLDER pidf2) { if ((DWORD)MAKELONG(pidf1->timeModified, pidf1->dateModified) < (DWORD)MAKELONG(pidf2->timeModified, pidf2->dateModified)) { return ResultFromShort(-1); } if ((DWORD)MAKELONG(pidf1->timeModified, pidf1->dateModified) > (DWORD)MAKELONG(pidf2->timeModified, pidf2->dateModified)) { return ResultFromShort(1); } return ResultFromShort(0); } HRESULT CFSFolder::_CompareCreateTime(LPCIDFOLDER pidf1, LPCIDFOLDER pidf2) { WIN32_FIND_DATAW wfd1, wfd2; if (SUCCEEDED(_FindDataFromIDFolder(pidf1, &wfd1, FALSE)) && SUCCEEDED(_FindDataFromIDFolder(pidf2, &wfd2, FALSE))) { return ResultFromShort(CompareFileTime(&wfd1.ftCreationTime, &wfd2.ftCreationTime)); } return ResultFromShort(0); } HRESULT CFSFolder::_CompareAccessTime(LPCIDFOLDER pidf1, LPCIDFOLDER pidf2) { WIN32_FIND_DATAW wfd1, wfd2; if (SUCCEEDED(_FindDataFromIDFolder(pidf1, &wfd1, FALSE)) && SUCCEEDED(_FindDataFromIDFolder(pidf2, &wfd2, FALSE))) { return ResultFromShort(CompareFileTime(&wfd1.ftLastAccessTime, &wfd2.ftLastAccessTime)); } return ResultFromShort(0); } HRESULT CFSFolder::_CompareAttribs(LPCIDFOLDER pidf1, LPCIDFOLDER pidf2) { const DWORD mask = FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_COMPRESSED| FILE_ATTRIBUTE_ENCRYPTED | FILE_ATTRIBUTE_OFFLINE; // Calculate value of desired bits in attribute DWORD. DWORD dwValueA = pidf1->wAttrs & mask; DWORD dwValueB = pidf2->wAttrs & mask; if (dwValueA != dwValueB) { // If the values are not equal, // sort alphabetically based on string representation. TCHAR szTempA[ARRAYSIZE(g_adwAttributeBits) + 1]; TCHAR szTempB[ARRAYSIZE(g_adwAttributeBits) + 1]; // Create attribute string for objects A and B. BuildAttributeString(pidf1->wAttrs, szTempA, ARRAYSIZE(szTempA)); BuildAttributeString(pidf2->wAttrs, szTempB, ARRAYSIZE(szTempB)); // Compare attribute strings and determine difference. int diff = ustrcmp(szTempA, szTempB); if (diff > 0) return ResultFromShort(1); if (diff < 0) return ResultFromShort(-1); } return ResultFromShort(0); } HRESULT CFSFolder::_CompareFolderness(LPCIDFOLDER pidf1, LPCIDFOLDER pidf2) { if (_IsReal(pidf1) && _IsReal(pidf2)) { // Always put the folders first if (_IsFolder(pidf1)) { if (!_IsFolder(pidf2)) return ResultFromShort(-1); } else if (_IsFolder(pidf2)) return ResultFromShort(1); } return ResultFromShort(0); // same } HRESULT CFSFolder::CompareIDs(LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2) { HRESULT hr; LPCIDFOLDER pidf1 = _IsValidID(pidl1); LPCIDFOLDER pidf2 = _IsValidID(pidl2); if (!pidf1 || !pidf2) { // ASSERT(0); // we hit this often... who is the bad guy? return E_INVALIDARG; } hr = _CompareFolderness(pidf1, pidf2); if (hr != ResultFromShort(0)) return hr; // SHCIDS_ALLFIELDS means to compare absolutely, ie: even if only filetimes // are different, we rule file pidls to be different int iColumn = ((DWORD)lParam & SHCIDS_COLUMNMASK); switch (iColumn) { case FS_ICOL_SIZE: { ULONGLONG ull1 = _Size(pidf1); ULONGLONG ull2 = _Size(pidf2); if (ull1 < ull2) return ResultFromShort(-1); if (ull1 > ull2) return ResultFromShort(1); } goto DoDefault; case FS_ICOL_TYPE: hr = _CompareFileTypes(pidf1, pidf2); if (!hr) goto DoDefault; break; case FS_ICOL_WRITETIME: hr = _CompareModifiedDate(pidf1, pidf2); if (!hr) goto DoDefault; break; case FS_ICOL_NAME: hr = _CompareNames(pidf1, pidf2, TRUE, BOOLIFY((SHCIDS_CANONICALONLY & lParam))); if (hr == ResultFromShort(0)) { // pidl1 is not simple hr = ILCompareRelIDs(this, pidl1, pidl2, lParam); goto DoDefaultModification; } break; case FS_ICOL_CREATETIME: hr = _CompareCreateTime(pidf1, pidf2); if (!hr) goto DoDefault; break; case FS_ICOL_ACCESSTIME: hr = _CompareAccessTime(pidf1, pidf2); if (!hr) goto DoDefault; break; case FS_ICOL_ATTRIB: hr = _CompareAttribs(pidf1, pidf2); if (hr) return hr; goto DoDefault; default: iColumn -= ARRAYSIZE(c_fs_cols); // 99/03/24 #295631 vtan: If not one of the standard columns then // it's probably an extended column. Make a check for dates. // 99/05/18 #341468 vtan: But also fail if it is an extended column // because this implementation of IShellFolder::CompareIDs only // understands basic file system columns and extended date columns. if (iColumn >= 0) { hr = _CompareExtendedProp(iColumn, pidf1, pidf2); if (hr) return hr; } DoDefault: hr = _CompareNames(pidf1, pidf2, FALSE, BOOLIFY((SHCIDS_CANONICALONLY & lParam))); } DoDefaultModification: // If they were equal so far, but the caller wants SHCIDS_ALLFIELDS, // then look closer. if ((S_OK == hr) && (lParam & SHCIDS_ALLFIELDS)) { // Must sort by modified date to pick up any file changes! hr = _CompareModifiedDate(pidf1, pidf2); if (!hr) hr = _CompareAttribs(pidf1, pidf2); } return hr; } // test to see if this folder object is a net folder BOOL CFSFolder::_IsNetPath() { BOOL fRemote = FALSE; // assume no TCHAR szPath[MAX_PATH]; if (SUCCEEDED(_GetPath(szPath))) { fRemote = PathIsRemote(szPath); } return fRemote; } BOOL _CanRenameFolder(LPCTSTR pszFolder) { static const UINT c_aiNoRenameFolders[] = { CSIDL_WINDOWS, CSIDL_SYSTEM, CSIDL_PROGRAM_FILES, CSIDL_FONTS, }; return !PathIsOneOf(pszFolder, c_aiNoRenameFolders, ARRAYSIZE(c_aiNoRenameFolders)); } STDAPI_(LPCIDFOLDER) CFSFolder::_IsValidIDHack(LPCITEMIDLIST pidl) { if (!(ACF_NOVALIDATEFSIDS & SHGetAppCompatFlags(ACF_NOVALIDATEFSIDS))) { return _IsValidID(pidl); } else if (pidl) { // old behavior was that we didnt validate, we just // looked for the last id and casted it return (LPCIDFOLDER)ILFindLastID(pidl); } return NULL; } #define SFGAO_NOT_RECENT (SFGAO_CANRENAME | SFGAO_CANLINK) #define SFGAO_REQ_MASK (SFGAO_HASSUBFOLDER | SFGAO_FILESYSANCESTOR | SFGAO_FOLDER | SFGAO_DROPTARGET | SFGAO_LINK | SFGAO_STREAM | SFGAO_STORAGEANCESTOR | SFGAO_STORAGE | SFGAO_READONLY) HRESULT CFSFolder::GetAttributesOf(UINT cidl, LPCITEMIDLIST *apidl, ULONG *prgfInOut) { LPCIDFOLDER pidf = cidl ? _IsValidIDHack(apidl[0]) : NULL; ULONG rgfOut = SFGAO_CANDELETE | SFGAO_CANMOVE | SFGAO_CANCOPY | SFGAO_HASPROPSHEET | SFGAO_FILESYSTEM | SFGAO_DROPTARGET | SFGAO_CANRENAME | SFGAO_CANLINK; ASSERT(cidl ? apidl[0] == ILFindLastID(apidl[0]) : TRUE); // should be single level IDs only ASSERT(cidl ? BOOLFROMPTR(pidf) : TRUE); // should always be FS PIDLs // the RECENT folder doesnt like items in it renamed or linked to. if ((*prgfInOut & (SFGAO_NOT_RECENT)) && _IsCSIDL(CSIDL_RECENT)) { rgfOut &= ~SFGAO_NOT_RECENT; } if (cidl == 1 && pidf) { CFileSysItemString fsi(pidf); TCHAR szPath[MAX_PATH]; if (*prgfInOut & (SFGAO_VALIDATE | SFGAO_CANRENAME | SFGAO_REMOVABLE | SFGAO_SHARE)) { HRESULT hr = _GetPathForItem(pidf, szPath); if (FAILED(hr)) return hr; } else { // just in case -- if somebody else needs the path they should add to the check above szPath[0] = 0; } if (*prgfInOut & SFGAO_VALIDATE) { DWORD dwAttribs; if (!PathFileExistsAndAttributes(szPath, &dwAttribs)) return E_FAIL; // Tell the extended columns to update when someone request validation of a pidl // This allows a client of the shell folder who uses extended columns without a // view to force an update on stale information (i.e. Start Menu with InfoTips) // - lamadio 6.11.99 _bUpdateExtendedCols = TRUE; // hackhack. if they pass in validate, we party into it and update // the attribs if (!IsBadWritePtr((void *)&pidf->wAttrs, sizeof(pidf->wAttrs))) ((LPIDFOLDER)pidf)->wAttrs = (WORD)dwAttribs; } if (*prgfInOut & SFGAO_COMPRESSED) { if (pidf->wAttrs & FILE_ATTRIBUTE_COMPRESSED) { rgfOut |= SFGAO_COMPRESSED; } } if (*prgfInOut & SFGAO_ENCRYPTED) { if (pidf->wAttrs & FILE_ATTRIBUTE_ENCRYPTED) { rgfOut |= SFGAO_ENCRYPTED; } } if (*prgfInOut & SFGAO_READONLY) { if ((pidf->wAttrs & FILE_ATTRIBUTE_READONLY) && !(pidf->wAttrs & FILE_ATTRIBUTE_DIRECTORY)) { rgfOut |= SFGAO_READONLY; } } if (*prgfInOut & SFGAO_HIDDEN) { if (pidf->wAttrs & FILE_ATTRIBUTE_HIDDEN) { rgfOut |= SFGAO_HIDDEN; } } if (*prgfInOut & SFGAO_NONENUMERATED) { if (IsSuperHidden(pidf->wAttrs)) { // mark superhidden as nonenumerated, IsSuperHidden checks current settings rgfOut |= SFGAO_NONENUMERATED; } else if (pidf->wAttrs & FILE_ATTRIBUTE_HIDDEN) { // mark normal hidden as nonenumerated if necessary SHELLSTATE ss; SHGetSetSettings(&ss, SSF_SHOWALLOBJECTS, FALSE); if (!ss.fShowAllObjects) { rgfOut |= SFGAO_NONENUMERATED; } } } if (_IsFolder(pidf)) { rgfOut |= SFGAO_FOLDER | SFGAO_STORAGE | SFGAO_FILESYSANCESTOR | SFGAO_STORAGEANCESTOR; if ((*prgfInOut & SFGAO_CANRENAME) && (fsi.CantRename(this) || !_CanRenameFolder(szPath))) rgfOut &= ~SFGAO_CANRENAME; if ((*prgfInOut & SFGAO_REMOVABLE) && PathIsRemovable(szPath)) { rgfOut |= SFGAO_REMOVABLE; } if ((*prgfInOut & SFGAO_SHARE) && IsShared(szPath, FALSE)) { rgfOut |= SFGAO_SHARE; } } else { rgfOut |= SFGAO_STREAM; } if (*prgfInOut & SFGAO_LINK) { DWORD dwFlags = fsi.ClassFlags(FALSE); if (dwFlags & SHCF_IS_LINK) { rgfOut |= SFGAO_LINK; } } CLSID clsid; if (fsi.GetJunctionClsid(&clsid, TRUE)) { // NOTE: here we are always including SFGAO_FILESYSTEM. this was not the original // shell behavior. but since these things will succeeded on SHGetPathFromIDList() // it is the right thing to do. to filter out SFGAO_FOLDER things that might // have files in them use SFGAO_FILESYSANCESTOR. // // clear out the things we want the extension to be able to optionally have rgfOut &= ~(SFGAO_DROPTARGET | SFGAO_STORAGE | SFGAO_FILESYSANCESTOR | SFGAO_STORAGEANCESTOR); // let folder shortcuts yank the folder bit too for bad apps. if (IsEqualGUID(clsid, CLSID_FolderShortcut) && (SHGetAppCompatFlags(ACF_STRIPFOLDERBIT) & ACF_STRIPFOLDERBIT)) { rgfOut &= ~SFGAO_FOLDER; } // and let him add some bits in rgfOut |= SHGetAttributesFromCLSID2(&clsid, SFGAO_HASSUBFOLDER, SFGAO_REQ_MASK) & SFGAO_REQ_MASK; // Mill #123708 // prevent zips, cabs and other files with SFGAO_FOLDER set // from being treated like folders inside bad file open dialogs. if (!(pidf->wAttrs & FILE_ATTRIBUTE_DIRECTORY) && (SHGetAppCompatFlags (ACF_STRIPFOLDERBIT) & ACF_STRIPFOLDERBIT)) { rgfOut &= ~SFGAO_FOLDER; } // Check if this folder needs File System Ancestor bit if ((rgfOut & SFGAO_FOLDER) && !(rgfOut & SFGAO_FILESYSANCESTOR) && SHGetObjectCompatFlags(NULL, &clsid) & OBJCOMPATF_NEEDSFILESYSANCESTOR) { rgfOut |= SFGAO_FILESYSANCESTOR; } } // it can only have subfolders if we've first found it's a folder if ((rgfOut & SFGAO_FOLDER) && (*prgfInOut & SFGAO_HASSUBFOLDER)) { if (pidf->wAttrs & FILE_ATTRIBUTE_REPARSE_POINT) { rgfOut |= SFGAO_HASSUBFOLDER; // DFS junction, local mount point, assume sub folders } else if (_IsNetPath()) { // it would be nice to not assume this. this messes up // home net cases where we get the "+" wrong rgfOut |= SFGAO_HASSUBFOLDER; // assume yes because these are slow } else if (!(rgfOut & SFGAO_HASSUBFOLDER)) { IShellFolder *psf; if (SUCCEEDED(_Bind(NULL, pidf, IID_PPV_ARG(IShellFolder, &psf)))) { IEnumIDList *peunk; if (S_OK == psf->EnumObjects(NULL, SHCONTF_FOLDERS, &peunk)) { LPITEMIDLIST pidlT; if (peunk->Next(1, &pidlT, NULL) == S_OK) { rgfOut |= SFGAO_HASSUBFOLDER; SHFree(pidlT); } peunk->Release(); } psf->Release(); } } } if (*prgfInOut & SFGAO_GHOSTED) { if (pidf->wAttrs & FILE_ATTRIBUTE_HIDDEN) rgfOut |= SFGAO_GHOSTED; } if ((*prgfInOut & SFGAO_BROWSABLE) && (_IsFile(pidf)) && (fsi.ClassFlags(FALSE) & SHCF_IS_BROWSABLE)) { rgfOut |= SFGAO_BROWSABLE; } } *prgfInOut = rgfOut; return S_OK; } // load handler for an item based on the handler type: // DropHandler, IconHandler, etc. // in: // pidf type of this object specifies the type of handler - can be multilevel // pszHandlerType handler type name "DropTarget", may be NULL // riid interface to talk on // out: // ppv output object // HRESULT CFSFolder::_LoadHandler(LPCIDFOLDER pidf, DWORD grfMode, LPCTSTR pszHandlerType, REFIID riid, void **ppv) { HRESULT hr = E_FAIL; TCHAR szIID[40]; ASSERT(_FindJunctionNext(pidf) == NULL); // no extra non file sys goo please *ppv = NULL; // empty handler type, use the stringized IID as the handler name if (NULL == pszHandlerType) { szIID[0] = 0; SHStringFromGUID(riid, szIID, ARRAYSIZE(szIID)); pszHandlerType = szIID; } CFileSysItemString fsi(_FindLastID(pidf)); IAssociationArray *paa; hr = fsi.AssocCreate(this, FALSE, IID_PPV_ARG(IAssociationArray, &paa)); if (SUCCEEDED(hr)) { CSmartCoTaskMem spszClsid; hr = paa->QueryString(ASSOCELEM_MASK_QUERYNORMAL, AQNS_SHELLEX_HANDLER, pszHandlerType, &spszClsid); if (SUCCEEDED(hr)) { hr = _HandlerCreateInstance(pidf, spszClsid, grfMode, riid, ppv); } paa->Release(); } return hr; } HRESULT CFSFolder::_HandlerCreateInstance(LPCIDFOLDER pidf, PCWSTR pszClsid, DWORD grfMode, REFIID riid, void **ppv) { IPersistFile *ppf; HRESULT hr = SHExtCoCreateInstance(pszClsid, NULL, NULL, IID_PPV_ARG(IPersistFile, &ppf)); if (SUCCEEDED(hr)) { WCHAR wszPath[MAX_PATH]; hr = _GetPathForItem(pidf, wszPath); if (SUCCEEDED(hr)) { hr = ppf->Load(wszPath, grfMode); if (SUCCEEDED(hr)) { hr = ppf->QueryInterface(riid, ppv); } } ppf->Release(); } return hr; } HRESULT CFSFolder::_CreateShimgvwExtractor(LPCIDFOLDER pidf, REFIID riid, void **ppv) { HRESULT hr = E_FAIL; CFileSysItemString fsi(pidf); if (fsi.IsShimgvwImage()) { // cocreate CLSID_GdiThumbnailExtractor implemented in shimgvw.dll hr = _HandlerCreateInstance(pidf, L"{3F30C968-480A-4C6C-862D-EFC0897BB84B}", STGM_READ, riid, ppv); } return hr; } int CFSFolder::_GetDefaultFolderIcon() { int iIcon = II_FOLDER; UINT csidlFolder = _GetCSIDL(); // We're removing the icon distinction between per user and common folders. switch (csidlFolder) { case CSIDL_STARTMENU: case CSIDL_COMMON_STARTMENU: case CSIDL_PROGRAMS: case CSIDL_COMMON_PROGRAMS: iIcon = II_STSPROGS; break; } return iIcon; } DWORD CFSFolder::_Attributes() { if (_dwAttributes == -1) { TCHAR szPath[MAX_PATH]; if (SUCCEEDED(_GetPath(szPath))) _dwAttributes = GetFileAttributes(szPath); if (_dwAttributes == -1) _dwAttributes = FILE_ATTRIBUTE_DIRECTORY; // assume this on failure } return _dwAttributes; } // non junction, but has the system or readonly bit (regular folder marked special for us) BOOL CFSFolder::_IsSelfSystemFolder() { return (_Attributes() & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)); } // Determine if there is a LocalizedFileName section in our desktop.ini file BOOL CFSFolder::_HasLocalizedFileNames() { if (_tbHasLocalizedFileNamesSection == TRIBIT_UNDEFINED) { TCHAR szPath[MAX_PATH]; TCHAR szName[MAX_PATH]; TCHAR szBuf[4]; _GetPath(szPath); if (_GetIniPath(FALSE, szPath, _pszNetProvider, szName) && GetPrivateProfileSection(TEXT("LocalizedFileNames"), szBuf, sizeof(szBuf)/sizeof(TCHAR), szName) > 0) _tbHasLocalizedFileNamesSection = TRIBIT_TRUE; else _tbHasLocalizedFileNamesSection = TRIBIT_FALSE; } return (_tbHasLocalizedFileNamesSection == TRIBIT_TRUE); } // This function creates a default IExtractIcon object for either // a file or a junction point. We should not supposed to call this function // for a non-junction point directory (we don't want to hit the disk!). HRESULT CFSFolder::_CreateDefExtIcon(LPCIDFOLDER pidf, REFIID riid, void **ppxicon) { HRESULT hr = E_OUTOFMEMORY; DWORD dwFlags; // WARNING: don't replace this if-statement with _IsFolder(pidf))!!! // otherwise all junctions (like briefcase) will get the Folder icon. // if (_IsFileFolder(pidf)) { UINT iIcon = _GetDefaultFolderIcon(); UINT iIconOpen = II_FOLDEROPEN; TCHAR szPath[MAX_PATH], szModule[MAX_PATH]; szModule[0] = 0; if (_GetMountingPointInfo(pidf, szPath, ARRAYSIZE(szPath))) { // We want same icon for open and close moun point (kind of drive) iIconOpen = iIcon = GetMountedVolumeIcon(szPath, szModule, ARRAYSIZE(szModule)); } else if (_IsSystemFolder(pidf)) { if (_GetFolderIconPath(pidf, szPath, ARRAYSIZE(szPath), &iIcon)) { return SHCreateDefExtIcon(szPath, iIcon, iIcon, GIL_PERINSTANCE, II_FOLDER, riid, ppxicon); } } return SHCreateDefExtIcon(szModule, iIcon, iIconOpen, GIL_PERCLASS, II_FOLDER, riid, ppxicon); } // not a folder, get IExtractIcon and extract it. // (might be a ds folder) CFileSysItemString fsi(pidf); dwFlags = fsi.ClassFlags(TRUE); if (dwFlags & SHCF_ICON_PERINSTANCE) { if (dwFlags & SHCF_HAS_ICONHANDLER) { IUnknown *punk; hr = _LoadHandler(pidf, STGM_READ, TEXT("IconHandler"), IID_PPV_ARG(IUnknown, &punk)); if (SUCCEEDED(hr)) { hr = punk->QueryInterface(riid, ppxicon); punk->Release(); } else { *ppxicon = NULL; } } else { DWORD uid = _GetUID(pidf); TCHAR szPath[MAX_PATH]; hr = _GetPathForItem(pidf, szPath); if (SUCCEEDED(hr)) { hr = SHCreateDefExtIcon(szPath, uid, uid, GIL_PERINSTANCE | GIL_NOTFILENAME, -1, riid, ppxicon); } } } else { UINT iIcon = (dwFlags & SHCF_ICON_INDEX); if (II_FOLDER == iIcon) { iIcon = _GetDefaultFolderIcon(); } hr = SHCreateDefExtIcon(c_szStar, iIcon, iIcon, GIL_PERCLASS | GIL_NOTFILENAME, -1, riid, ppxicon); } return hr; } DWORD CALLBACK CFSFolder::_PropertiesThread(void *pv) { PROPSTUFF * pps = (PROPSTUFF *)pv; STGMEDIUM medium; ULONG_PTR dwCookie = 0; ActivateActCtx(NULL, &dwCookie); LPIDA pida = DataObj_GetHIDA(pps->pdtobj, &medium); if (pida) { LPITEMIDLIST pidl = IDA_ILClone(pida, 0); if (pidl) { TCHAR szPath[MAX_PATH]; LPTSTR pszCaption; HKEY rgKeys[MAX_ASSOC_KEYS] = {0}; DWORD cKeys = SHGetAssocKeysForIDList(pidl, rgKeys, ARRAYSIZE(rgKeys)); // REVIEW: psb? pszCaption = SHGetCaption(medium.hGlobal); SHOpenPropSheet(pszCaption, rgKeys, cKeys, &CLSID_ShellFileDefExt, pps->pdtobj, NULL, pps->pStartPage); if (pszCaption) SHFree(pszCaption); SHRegCloseKeys(rgKeys, cKeys); if (SHGetPathFromIDList(pidl, szPath)) { if (lstrcmpi(PathFindExtension(szPath), TEXT(".pif")) == 0) { DebugMsg(TF_FSTREE, TEXT("cSHCNRF_pt: DOS properties done, generating event.")); SHChangeNotify(SHCNE_UPDATEITEM, SHCNF_IDLIST, pidl, NULL); } } ILFree(pidl); } HIDA_ReleaseStgMedium(pida, &medium); } return 0; } // // Display a property sheet for a set of files. // The data object supplied must provide the "Shell IDList Array" // clipboard format. // The dwFlags argument is provided for future expansion. It is // currently unused. // STDAPI SHMultiFileProperties(IDataObject *pdtobj, DWORD dwFlags) { return SHLaunchPropSheet(CFSFolder::_PropertiesThread, pdtobj, 0, NULL, NULL); } HMENU FindMenuBySubMenuID(HMENU hmenu, UINT id, LPINT pIndex) { HMENU hmenuReturn = NULL; MENUITEMINFO mii; mii.cbSize = sizeof(mii); mii.fMask = MIIM_ID; mii.cch = 0; // just in case... for (int cMax = GetMenuItemCount(hmenu) - 1 ; cMax >= 0 ; cMax--) { HMENU hmenuSub = GetSubMenu(hmenu, cMax); if (hmenuSub && GetMenuItemInfo(hmenuSub, 0, TRUE, &mii)) { if (mii.wID == id) { // found it! hmenuReturn = hmenuSub; break; } } } if (hmenuReturn && pIndex) *pIndex = cMax; return hmenuReturn; } void DeleteMenuBySubMenuID(HMENU hmenu, UINT id) { int i; if (FindMenuBySubMenuID(hmenu, id, &i)) { DeleteMenu(hmenu, i, MF_BYPOSITION); } } // fMask is from CMIC_MASK_* STDAPI CFSFolder_CreateLinks(HWND hwnd, IShellFolder *psf, IDataObject *pdtobj, LPCTSTR pszDir, DWORD fMask) { LPITEMIDLIST pidl; HRESULT hr = SHGetIDListFromUnk(psf, &pidl); if (SUCCEEDED(hr)) { TCHAR szPath[MAX_PATH]; if (SHGetPathFromIDList(pidl, szPath)) { UINT fCreateLinkFlags; int cItems = DataObj_GetHIDACount(pdtobj); LPITEMIDLIST *ppidl = (LPITEMIDLIST *)LocalAlloc(LPTR, sizeof(LPITEMIDLIST) * cItems); // passing ppidl == NULL is correct in failure case if ((pszDir == NULL) || (lstrcmpi(pszDir, szPath) == 0)) { // create the link in the current folder fCreateLinkFlags = SHCL_USETEMPLATE; } else { // this is a sys menu, ask to create on desktop fCreateLinkFlags = SHCL_USETEMPLATE | SHCL_USEDESKTOP; if (!(fMask & CMIC_MASK_FLAG_NO_UI)) { fCreateLinkFlags |= SHCL_CONFIRM; } } hr = SHCreateLinks(hwnd, szPath, pdtobj, fCreateLinkFlags, ppidl); if (ppidl) { // select those objects; HWND hwndSelect = ShellFolderViewWindow(hwnd); // select the new links, but on the first one deselect all other selected things for (int i = 0; i < cItems; i++) { if (ppidl[i]) { SendMessage(hwndSelect, SVM_SELECTITEM, i == 0 ? SVSI_SELECT | SVSI_ENSUREVISIBLE | SVSI_DESELECTOTHERS | SVSI_FOCUSED : SVSI_SELECT, (LPARAM)ILFindLastID(ppidl[i])); ILFree(ppidl[i]); } } LocalFree((HLOCAL)ppidl); } } else { hr = E_FAIL; } ILFree(pidl); } return hr; } // Parameter to the "Delete" thread. // typedef struct { IDataObject *pDataObj; // null on entry to thread proc IStream *pstmDataObj; // marshalled data object HWND hwndOwner; UINT uFlags; UINT fOptions; } FSDELTHREADPARAM; void FreeFSDELThreadParam(FSDELTHREADPARAM * pfsthp) { ATOMICRELEASE(pfsthp->pDataObj); ATOMICRELEASE(pfsthp->pstmDataObj); LocalFree(pfsthp); } DWORD CALLBACK FileDeleteThreadProc(void *pv) { FSDELTHREADPARAM *pfsthp = (FSDELTHREADPARAM *)pv; CoGetInterfaceAndReleaseStream(pfsthp->pstmDataObj, IID_PPV_ARG(IDataObject, &pfsthp->pDataObj)); pfsthp->pstmDataObj = NULL; if (pfsthp->pDataObj) DeleteFilesInDataObject(pfsthp->hwndOwner, pfsthp->uFlags, pfsthp->pDataObj, pfsthp->fOptions); FreeFSDELThreadParam(pfsthp); return 0; } // // IContextMenuCB // right click context menu for items handler // // Returns: // S_OK, if successfully processed. // S_FALSE, if default code should be used. // STDMETHODIMP CFSFolder::CallBack(IShellFolder *psf, HWND hwnd, IDataObject *pdtobj, UINT uMsg, WPARAM wParam, LPARAM lParam) { HRESULT hr = S_OK; switch (uMsg) { case DFM_MERGECONTEXTMENU: if (!(wParam & CMF_VERBSONLY)) { LPQCMINFO pqcm = (LPQCMINFO)lParam; // corel relies on the hard coded send to menu so we give them one BOOL bCorelSuite7Hack = (SHGetAppCompatFlags(ACF_CONTEXTMENU) & ACF_CONTEXTMENU); if (bCorelSuite7Hack) { CDefFolderMenu_MergeMenu(HINST_THISDLL, POPUP_FSVIEW_ITEM_COREL7_HACK, 0, pqcm); } } break; case DFM_GETHELPTEXT: LoadStringA(HINST_THISDLL, LOWORD(wParam) + IDS_MH_FSIDM_FIRST, (LPSTR)lParam, HIWORD(wParam));; break; case DFM_GETHELPTEXTW: LoadStringW(HINST_THISDLL, LOWORD(wParam) + IDS_MH_FSIDM_FIRST, (LPWSTR)lParam, HIWORD(wParam));; break; case DFM_INVOKECOMMANDEX: { DFMICS *pdfmics = (DFMICS *)lParam; switch (wParam) { case DFM_CMD_DELETE: // try not to do delete on the UI thread // with System Restore it may be slow // // NOTE: we need to test to make sure this is acceptable as the data // object may have come from a data object extension, for example a // scrap file. but that is a very rare case (DataObj_CanGoAsync() will almost always // return true). hr = E_FAIL; if ((pdfmics->fMask & CMIC_MASK_ASYNCOK) && DataObj_CanGoAsync(pdtobj)) { FSDELTHREADPARAM *pfsthp; hr = SHLocalAlloc(sizeof(*pfsthp), &pfsthp); if (SUCCEEDED(hr)) { hr = CoMarshalInterThreadInterfaceInStream(IID_IDataObject, pdtobj, &pfsthp->pstmDataObj); if (SUCCEEDED(hr)) { pfsthp->hwndOwner = hwnd; pfsthp->uFlags = pdfmics->fMask; // dont allow undo in the recent folder. pfsthp->fOptions = _IsCSIDL(CSIDL_RECENT) ? SD_NOUNDO : 0; // create another thread to avoid blocking the source thread. if (!SHCreateThread(FileDeleteThreadProc, pfsthp, CTF_COINIT, NULL)) { hr = E_FAIL; } } if (FAILED(hr)) { FreeFSDELThreadParam(pfsthp); // cleanup } } } if (S_OK != hr) { // could not go async, do it sync here // dont allow undo in the recent folder. hr = DeleteFilesInDataObject(hwnd, pdfmics->fMask, pdtobj, _IsCSIDL(CSIDL_RECENT) ? SD_NOUNDO : 0); } break; case DFM_CMD_LINK: hr = CFSFolder_CreateLinks(hwnd, psf, pdtobj, (LPCTSTR)pdfmics->lParam, pdfmics->fMask); break; case DFM_CMD_PROPERTIES: hr = SHLaunchPropSheet(_PropertiesThread, pdtobj, (LPCTSTR)pdfmics->lParam, NULL, _pidl); break; default: // This is common menu items, use the default code. hr = S_FALSE; break; } } break; default: hr = E_NOTIMPL; break; } return hr; } HRESULT CFSFolder::_CreateContextMenu(HWND hwnd, LPCIDFOLDER pidf, LPCITEMIDLIST *apidl, UINT cidl, IContextMenu **ppcm) { // we need a key for each // 1. UserCustomized // 2. default Progid // 3. SFA\.ext // 4. SFA\PerceivedType // 5. * or Folder // 6. AllFileSystemObjects // (?? 7. maybe pszProvider ??) IAssociationArray *paa; CFileSysItemString fsi(pidf); fsi.AssocCreate(this, TRUE, IID_PPV_ARG(IAssociationArray, &paa)); IShellFolder *psfToPass; // May be an Aggregate... HRESULT hr = QueryInterface(IID_PPV_ARG(IShellFolder, &psfToPass)); if (SUCCEEDED(hr)) { DEFCONTEXTMENU dcm = { hwnd, SAFECAST(this, IContextMenuCB *), _pidl, psfToPass, cidl, apidl, paa, 0, NULL}; hr = CreateDefaultContextMenu(&dcm, ppcm); psfToPass->Release(); } if (paa) paa->Release(); return hr; } HRESULT CFileFolderIconManager_Create(IShellFolder *psf, LPCITEMIDLIST pidl, REFIID riid, void **ppv); HRESULT CFSFolder::GetUIObjectOf(HWND hwnd, UINT cidl, LPCITEMIDLIST *apidl, REFIID riid, UINT *prgfInOut, void **ppv) { HRESULT hr = E_INVALIDARG; LPCIDFOLDER pidf = cidl ? _IsValidID(apidl[0]) : NULL; *ppv = NULL; if (pidf && (IsEqualIID(riid, IID_IExtractIconA) || IsEqualIID(riid, IID_IExtractIconW))) { hr = _CreateDefExtIcon(pidf, riid, ppv); } else if (IsEqualIID(riid, IID_IContextMenu) && pidf) { hr = _CreateContextMenu(hwnd, pidf, apidl, cidl, (IContextMenu **)ppv); } else if (IsEqualIID(riid, IID_IDataObject) && cidl) { IDataObject *pdtInner = NULL; if ((cidl == 1) && pidf) { _LoadHandler(pidf, STGM_READ, TEXT("DataHandler"), IID_PPV_ARG(IDataObject, &pdtInner)); } hr = SHCreateFileDataObject(_pidl, cidl, apidl, pdtInner, (IDataObject **)ppv); if (pdtInner) pdtInner->Release(); } else if (IsEqualIID(riid, IID_IDropTarget) && pidf) { CLSID clsid; if (_IsFolder(pidf) || (_GetJunctionClsid(pidf, &clsid) && !SHQueryShellFolderValue(&clsid, L"UseDropHandler"))) { IShellFolder *psfT; hr = BindToObject(apidl[0], NULL, IID_PPV_ARG(IShellFolder, &psfT)); if (SUCCEEDED(hr)) { hr = psfT->CreateViewObject(hwnd, riid, ppv); psfT->Release(); } } else { // old code supported absolute PIDLs here. that was bogus... ASSERT(ILIsEmpty(apidl[0]) || (ILFindLastID(apidl[0]) == apidl[0])); ASSERT(_IsFile(pidf) || _IsSimpleID(pidf)); hr = _LoadHandler(pidf, STGM_READ, TEXT("DropHandler"), riid, ppv); } } else if (IsEqualIID(riid, IID_ICustomIconManager) && pidf) { if (_IsFileFolder(pidf)) { TCHAR szItemPath[MAX_PATH]; szItemPath[0] = NULL; hr = _GetPath(szItemPath); if (SUCCEEDED(hr)) { // No support in ICustomIconManager for remote shares. if (PathIsNetworkPath(szItemPath)) hr = E_NOTIMPL; else { hr = CFileFolderIconManager_Create(this, (LPCITEMIDLIST)pidf, riid, ppv); } } } else { hr = E_NOTIMPL; } } else if (pidf) { // too many people bogusly register extractors that // dont work as well as ours for images // we hard code our list of supported types. if (IsEqualIID(riid, IID_IExtractImage)) { hr = _CreateShimgvwExtractor(pidf, riid, ppv); } if (FAILED(hr)) hr = _LoadHandler(pidf, STGM_READ, NULL, riid, ppv); if (FAILED(hr)) { if (IsEqualIID(riid, IID_IQueryInfo)) { hr = _GetToolTipForItem(pidf, riid, ppv); } else if (IsEqualIID(riid, IID_IQueryAssociations) || IsEqualIID(riid, IID_IAssociationArray)) { hr = _AssocCreate(pidf, riid, ppv); } else if ((IsEqualIID(riid, IID_IExtractImage) || IsEqualIID(riid, IID_IExtractLogo)) && _IsFileFolder(pidf)) { // default handler type, use the IID_ as the key to open for the handler // if it is an image extractor, then check to see if it is a per-folder logo... hr = CFolderExtractImage_Create(this, (LPCITEMIDLIST)pidf, riid, ppv); } } } return hr; } HRESULT CFSFolder::GetDefaultSearchGUID(GUID *pGuid) { return E_NOTIMPL; } HRESULT CFSFolder::EnumSearches(IEnumExtraSearch **ppenum) { *ppenum = NULL; return E_NOTIMPL; } LPCIDFOLDER CFSFolder::_FindJunction(LPCIDFOLDER pidf) { for (; pidf->cb; pidf = _Next(pidf)) { if (_IsJunction(pidf)) return pidf; // true junction (folder.{guid} folder\desktop.ini) if (_IsFile(pidf)) { DWORD dwFlags = _GetClassFlags(pidf); if (dwFlags & (SHCF_IS_BROWSABLE | SHCF_IS_SHELLEXT)) return pidf; // browsable file (.HTM) } } return NULL; } // return IDLIST of item just past the junction point (if there is one) // if there's no next pointer, return NULL. LPCITEMIDLIST CFSFolder::_FindJunctionNext(LPCIDFOLDER pidf) { pidf = _FindJunction(pidf); if (pidf) { // cast here represents the fact that this data is opaque LPCITEMIDLIST pidl = (LPCITEMIDLIST)_Next(pidf); if (!ILIsEmpty(pidl)) return pidl; // first item past junction } return NULL; } void CFSFolder::_UpdateItem(LPCIDFOLDER pidf) { LPITEMIDLIST pidlAbs = ILCombine(_pidl, (LPCITEMIDLIST)pidf); if (pidlAbs) { SHChangeNotify(SHCNE_UPDATEITEM, SHCNF_FLUSH | SHCNF_IDLIST, pidlAbs, NULL); ILFree(pidlAbs); } } HRESULT CFSFolder::_SetLocalizedDisplayName(LPCIDFOLDER pidf, LPCWSTR pszName) { HRESULT hr = E_FAIL; WCHAR sz[MAX_PATH]; CFileSysItemString fsi(pidf); if (*pszName == TEXT('@') && SUCCEEDED(SHLoadIndirectString(pszName, sz, ARRAYSIZE(sz), NULL))) { TCHAR szPath[MAX_PATH]; // // this is a localized resource. // save this off as the items UI name. // if (_IsFolder(pidf)) { if (SUCCEEDED(_GetPathForItem(pidf, szPath)) && SetFolderString(TRUE, szPath, _pszNetProvider, STRINI_CLASSINFO, TEXT("LocalizedResourceName"), pszName)) { // we need to insure the bits are set for MUI on upgraded users // PathMakeSystemFolder(szPath); hr = S_OK; } } else { _GetPath(szPath); if (SetFolderString(TRUE, szPath, _pszNetProvider, TEXT("LocalizedFileNames"), fsi.FSName(), pszName)) hr = S_OK; } } else { if (fsi.HasResourceName()) { if (*pszName) { DWORD cb = CbFromCch(lstrlen(pszName)+1); // set the registry overrides if (S_OK == SKSetValueW(SHELLKEY_HKCU_SHELL, L"LocalizedResourceName", fsi.ResourceName(), REG_SZ, pszName, cb)) { hr = S_OK; } } else { SKDeleteValue(SHELLKEY_HKCU_SHELL, L"LocalizedResourceName", fsi.ResourceName()); hr = S_OK; } } } if (SUCCEEDED(hr)) _UpdateItem(pidf); return hr; } HRESULT CFSFolder::_NormalGetDisplayNameOf(LPCIDFOLDER pidf, STRRET *pStrRet) { // // WARNING - Some apps (e.g., Norton Uninstall Deluxe) // don't handle STRRET_WSTR properly. NT4's shell32 // returned STRRET_WSTR only if it had no choice, so these apps // seemed to run just fine on NT as long as you never had any // UNICODE filenames. We must preserve the NT4 behavior or // these buggy apps start blowing chunks. // // if this is still important, we will apphack these guys CFileSysItemString fsi(pidf); if (SHGetAppCompatFlags(ACF_ANSIDISPLAYNAMES) & ACF_ANSIDISPLAYNAMES) { pStrRet->uType = STRRET_CSTR; SHUnicodeToAnsi(fsi.UIName(this), pStrRet->cStr, ARRAYSIZE(pStrRet->cStr)); return S_OK; } return StringToStrRet(fsi.UIName(this), pStrRet); } HRESULT CFSFolder::_NormalDisplayName(LPCIDFOLDER pidf, LPTSTR psz, UINT cch) { CFileSysItemString fsi(pidf); StrCpyN(psz, fsi.UIName(this), cch); return S_OK; } HRESULT CFSFolder::GetDisplayNameOf(LPCITEMIDLIST pidl, DWORD dwFlags, LPSTRRET pStrRet) { HRESULT hr = S_FALSE; LPCIDFOLDER pidf = _IsValidID(pidl); if (pidf) { TCHAR szPath[MAX_PATH]; LPCITEMIDLIST pidlNext = _ILNext(pidl); if (dwFlags & SHGDN_FORPARSING) { if (dwFlags & SHGDN_INFOLDER) { _CopyName(pidf, szPath, ARRAYSIZE(szPath)); if (dwFlags & SHGDN_FORADDRESSBAR) { LPTSTR pszExt = PathFindCLSIDExtension(szPath, NULL); if (pszExt) *pszExt = 0; } if (ILIsEmpty(pidlNext)) // single level idlist hr = StringToStrRet(szPath, pStrRet); else hr = ILGetRelDisplayName(this, pStrRet, pidl, szPath, MAKEINTRESOURCE(IDS_DSPTEMPLATE_WITH_BACKSLASH), dwFlags); } else { LPIDFOLDER pidfBind; LPCITEMIDLIST pidlRight; hr = _GetJunctionForBind(pidf, &pidfBind, &pidlRight); if (SUCCEEDED(hr)) { if (hr == S_OK) { IShellFolder *psfJctn; hr = _Bind(NULL, pidfBind, IID_PPV_ARG(IShellFolder, &psfJctn)); if (SUCCEEDED(hr)) { hr = psfJctn->GetDisplayNameOf(pidlRight, dwFlags, pStrRet); psfJctn->Release(); } ILFree((LPITEMIDLIST)pidfBind); } else { hr = _GetPathForItem(pidf, szPath); if (SUCCEEDED(hr)) { if (dwFlags & SHGDN_FORADDRESSBAR) { LPTSTR pszExt = PathFindCLSIDExtension(szPath, NULL); if (pszExt) *pszExt = 0; } hr = StringToStrRet(szPath, pStrRet); } } } } } else if (_IsCSIDL(CSIDL_RECENT) && SUCCEEDED(RecentDocs_GetDisplayName((LPCITEMIDLIST)pidf, szPath, SIZECHARS(szPath)))) { LPITEMIDLIST pidlRecent; WIN32_FIND_DATA wfd = {0}; StrCpyN(wfd.cFileName, szPath, SIZECHARS(wfd.cFileName)); if (SUCCEEDED(_CreateIDList(&wfd, NULL, &pidlRecent))) { hr = _NormalGetDisplayNameOf((LPCIDFOLDER)pidlRecent, pStrRet); ILFree(pidlRecent); } } else { ASSERT(ILIsEmpty(pidlNext)); // this variation should be single level hr = _NormalGetDisplayNameOf(pidf, pStrRet); } } else { if (IsSelf(1, &pidl) && ((dwFlags & (SHGDN_FORADDRESSBAR | SHGDN_INFOLDER | SHGDN_FORPARSING)) == SHGDN_FORPARSING)) { TCHAR szPath[MAX_PATH]; hr = _GetPath(szPath); if (SUCCEEDED(hr)) hr = StringToStrRet(szPath, pStrRet); } else { hr = E_INVALIDARG; TraceMsg(TF_WARNING, "CFSFolder::GetDisplayNameOf() failing on PIDL %s", DumpPidl(pidl)); } } return hr; } void DoSmartQuotes(LPTSTR pszName) { LPTSTR pszFirst = StrChr(pszName, TEXT('"')); if (pszFirst) { LPTSTR pszSecond = StrChr(pszFirst + 1, TEXT('"')); if (pszSecond) { if (NULL == StrChr(pszSecond + 1, TEXT('"'))) { *pszFirst = 0x201C; // left double quotation *pszSecond = 0x201D; // right double quotation } } } } HRESULT _PrepareNameForRename(LPTSTR pszName) { if (*pszName) { HRESULT hr = _CheckPortName(pszName); if (SUCCEEDED(hr)) { DoSmartQuotes(pszName); } return hr; } // avoid a bogus error msg with blank name (treat as user cancel) return HRESULT_FROM_WIN32(ERROR_CANCELLED); } HRESULT CFSFolder::SetNameOf(HWND hwnd, LPCITEMIDLIST pidl, LPCOLESTR pszName, DWORD dwFlags, LPITEMIDLIST *ppidl) { HRESULT hr = E_INVALIDARG; if (ppidl) *ppidl = NULL; LPCIDFOLDER pidf = _IsValidID(pidl); if (pidf) { CFileSysItemString fsi(pidf); TCHAR szNewName[MAX_PATH]; SHUnicodeToTChar(pszName, szNewName, ARRAYSIZE(szNewName)); PathRemoveBlanks(szNewName); // leading and trailing blanks if (dwFlags == SHGDN_NORMAL || dwFlags == SHGDN_INFOLDER) { hr = _SetLocalizedDisplayName(pidf, pszName); if (SUCCEEDED(hr)) { // Return the new pidl if ppidl is specified. if (ppidl) return _CreateIDListFromName(fsi.FSName(), -1, NULL, ppidl); } else if (*pszName == TEXT('@') && PathParseIconLocation(szNewName + 1)) { // this is a localized string (eg "@C:\WINNT\System32\shell32.dll,-3") // so do not go on and try to call SHRenameFileEx return hr; } } if (FAILED(hr)) { hr = _PrepareNameForRename(szNewName); if (SUCCEEDED(hr)) { TCHAR szDir[MAX_PATH], szOldName[MAX_PATH]; _CopyName(pidf, szOldName, ARRAYSIZE(szOldName)); // If the extension is hidden if (!(dwFlags & SHGDN_FORPARSING) && !fsi.ShowExtension(_DefaultShowExt())) { // copy it from the old name StrCatBuff(szNewName, PathFindExtension(szOldName), ARRAYSIZE(szNewName)); } hr = _GetPath(szDir); if (SUCCEEDED(hr)) { UINT cchDirLen = lstrlen(szDir); // There are cases where the old name exceeded the maximum path, which // would give a bogus error message. To avoid this we should check for // this case and see if using the short name for the file might get // around this... // if (cchDirLen + lstrlen(szOldName) + 2 > MAX_PATH) { if (cchDirLen + lstrlenA(fsi.AltName()) + 2 <= MAX_PATH) SHAnsiToTChar(fsi.AltName(), szOldName, ARRAYSIZE(szOldName)); } // do a binary compare, locale insenstive compare to avoid mappings of // single chars into multiple and the reverse. specifically german // sharp-S and "ss" if (StrCmpC(szOldName, szNewName) == 0) { // when the before and after strings are identical we're okay with that. // SHRenameFileEx would return -1 in that case -- we check here to save // some stack. hr = S_OK; } else { // We need to impl ::SetSite() and pass it to SHRenameFile // to go modal if we display UI. int iRes = SHRenameFileEx(hwnd, NULL, szDir, szOldName, szNewName); hr = HRESULT_FROM_WIN32(iRes); } if (SUCCEEDED(hr) && ppidl) { // Return the new pidl if ppidl is specified. hr = _CreateIDListFromName(szNewName, -1, NULL, ppidl); } } } } } return hr; } HRESULT CFSFolder::_FindDataFromIDFolder(LPCIDFOLDER pidf, WIN32_FIND_DATAW *pfd, BOOL fAllowSimplePid) { HRESULT hr; CFileSysItemString fsi(pidf); if (!fAllowSimplePid) { hr = fsi.GetFindData(pfd); } else { hr = fsi.GetFindDataSimple(pfd); } return hr; } /*** To avoid registry explosion, each pidl is passed to each handler. HKCR\Folder\ColumnHandlers "" = "Docfile handler" "" = "Imagefile handler" ***/ void CFSFolder::_DestroyColHandlers() { if (_hdsaColHandlers) { for (int i = 0; i < DSA_GetItemCount(_hdsaColHandlers); i++) { COLUMNLISTENTRY *pcle = (COLUMNLISTENTRY *)DSA_GetItemPtr(_hdsaColHandlers, i); if (pcle->pcp) pcle->pcp->Release(); } DSA_Destroy(_hdsaColHandlers); _hdsaColHandlers = NULL; } } // returns the n'th handler for a given column BOOL CFSFolder::_FindColHandler(UINT iCol, UINT iN, COLUMNLISTENTRY *pcle) { for (int i = 0; i < DSA_GetItemCount(_hdsaColHandlers); i++) { COLUMNLISTENTRY *pcleWalk = (COLUMNLISTENTRY *)DSA_GetItemPtr(_hdsaColHandlers, i); if (pcleWalk->iColumnId == iCol) { if (iN-- == 0) { *pcle = *pcleWalk; return TRUE; } } } return FALSE; } HRESULT CFSFolder::_LoadColumnHandlers() { // Have we been here? if (NULL != _hdsaColHandlers) return S_OK; // nothing to do. ASSERT(0 == _dwColCount); SHCOLUMNINIT shci = {0}; // retrieve folder path for provider init HRESULT hr = _GetPathForItem(NULL, shci.wszFolder); if (SUCCEEDED(hr)) { _hdsaColHandlers = DSA_Create(sizeof(COLUMNLISTENTRY), 5); if (_hdsaColHandlers) { int iUniqueColumnCount = 0; HKEY hkCH; // Enumerate HKCR\Folder\Shellex\ColumnProviders // note: this really should have been "Directory", not "Folder" if (ERROR_SUCCESS == RegOpenKey(HKEY_CLASSES_ROOT, TEXT("Folder\\shellex\\ColumnHandlers"), &hkCH)) { TCHAR szHandlerCLSID[GUIDSTR_MAX]; int iHandler = 0; while (ERROR_SUCCESS == RegEnumKey(hkCH, iHandler++, szHandlerCLSID, ARRAYSIZE(szHandlerCLSID))) { CLSID clsid; IColumnProvider *pcp; if (SUCCEEDED(SHCLSIDFromString(szHandlerCLSID, &clsid)) && SUCCEEDED(SHExtCoCreateInstance(NULL, &clsid, NULL, IID_PPV_ARG(IColumnProvider, &pcp)))) { if (SUCCEEDED(pcp->Initialize(&shci))) { int iCol = 0; COLUMNLISTENTRY cle; cle.pcp = pcp; while (S_OK == pcp->GetColumnInfo(iCol++, &cle.shci)) { cle.pcp->AddRef(); cle.iColumnId = iUniqueColumnCount++; // Check if there's already a handler for this column ID, for (int i = 0; i < DSA_GetItemCount(_hdsaColHandlers); i++) { COLUMNLISTENTRY *pcleLoop = (COLUMNLISTENTRY *)DSA_GetItemPtr(_hdsaColHandlers, i); if (IsEqualSCID(pcleLoop->shci.scid, cle.shci.scid)) { cle.iColumnId = pcleLoop->iColumnId; // set the iColumnId to the same as the first one iUniqueColumnCount--; // so our count stays right break; } } DSA_AppendItem(_hdsaColHandlers, &cle); } } pcp->Release(); } } RegCloseKey(hkCH); } // Sanity check if (!DSA_GetItemCount(_hdsaColHandlers)) { // DSA_Destroy(*phdsa); ASSERT(iUniqueColumnCount==0); iUniqueColumnCount = 0; } _dwColCount = (DWORD)iUniqueColumnCount; } else { hr = E_OUTOFMEMORY; } } return hr; } // Initializes a SHCOLUMNDATA block. HRESULT CFSFolder::_InitColData(LPCIDFOLDER pidf, SHCOLUMNDATA* pscd) { ZeroMemory(pscd, sizeof(*pscd)); HRESULT hr = _GetPathForItem(pidf, pscd->wszFile); if (SUCCEEDED(hr)) { pscd->pwszExt = PathFindExtensionW(pscd->wszFile); pscd->dwFileAttributes = pidf->wAttrs; if (FILE_ATTRIBUTE_OFFLINE & pscd->dwFileAttributes) hr = E_FAIL; else if (_bUpdateExtendedCols) { // set the dwFlags member to tell the col handler to // not take data from it's cache pscd->dwFlags = SHCDF_UPDATEITEM; _bUpdateExtendedCols = FALSE; // only do this once! } } return hr; } // Note: // Setting _tbOfflineCSC = TRIBIT_UNDEFINED will retest the connection (good for a refresh). // Setting _tbOfflineCSC = { other } will use a little cache hooey for perf. // // Return: // TRUE pidl is offline // FALSE otherwise // BOOL CFSFolder::_IsOfflineCSC(LPCIDFOLDER pidf) { TCHAR szPath[MAX_PATH]; // Update local cached answer for _pidl (folder). if (_tbOfflineCSC == TRIBIT_UNDEFINED) { if (SUCCEEDED(_GetPath(szPath)) && _IsOfflineCSC(szPath)) _tbOfflineCSC = TRIBIT_TRUE; else _tbOfflineCSC = TRIBIT_FALSE; } ASSERT(_tbOfflineCSC != TRIBIT_UNDEFINED); // Calculate answer for pidl. BOOL bIsOffline; if (_tbOfflineCSC == TRIBIT_TRUE) bIsOffline = TRUE; else { bIsOffline = _IsFolder(pidf) && SUCCEEDED(_GetPathForItem(pidf, szPath)) && _IsOfflineCSC(szPath); } return bIsOffline; } // Make sure we have a UNC \\server\share path. Do this before checking // whether CSC is enabled, to avoid loading CSCDLL.DLL unless absolutely // necessary. BOOL CFSFolder::_IsOfflineCSC(LPCTSTR pszPath) { BOOL bUNC = FALSE; TCHAR szUNC[MAX_PATH]; szUNC[0] = 0; if (PathIsUNC(pszPath)) { StrCpyN(szUNC, pszPath, ARRAYSIZE(szUNC)); } else if (pszPath[1] == TEXT(':')) { TCHAR szLocalName[3] = { pszPath[0], pszPath[1], TEXT('\0') }; // Call GetDriveType() before WNetGetConnection(), to // avoid loading MPR.DLL unless absolutely necessary. if (DRIVE_REMOTE == GetDriveType(szLocalName)) { // ignore return, szUNC filled in on success DWORD cch = ARRAYSIZE(szUNC); WNetGetConnection(szLocalName, szUNC, &cch); } } return szUNC[0] && PathStripToRoot(szUNC) && (GetOfflineShareStatus(szUNC) == OFS_OFFLINE); } HRESULT CFSFolder::_ExtendedColumn(LPCIDFOLDER pidf, UINT iColumn, SHELLDETAILS *pDetails) { HRESULT hr = _LoadColumnHandlers(); if (SUCCEEDED(hr)) { if (iColumn < _dwColCount) { if (NULL == pidf) { COLUMNLISTENTRY cle; if (_FindColHandler(iColumn, 0, &cle)) { pDetails->fmt = cle.shci.fmt; pDetails->cxChar = cle.shci.cChars; hr = StringToStrRet(cle.shci.wszTitle, &pDetails->str); } else { hr = E_NOTIMPL; } } else { SHCOLUMNDATA shcd; hr = _InitColData(pidf, &shcd); if (SUCCEEDED(hr)) { hr = E_FAIL; // loop below will try to reset this // loop through all the column providers, breaking when one succeeds COLUMNLISTENTRY cle; for (int iTry = 0; _FindColHandler(iColumn, iTry, &cle); iTry++) { VARIANT var = {0}; hr = cle.pcp->GetItemData(&cle.shci.scid, &shcd, &var); if (SUCCEEDED(hr)) { if (S_OK == hr) { PROPERTYUI_FORMAT_FLAGS puiff = PUIFFDF_DEFAULT; if (pDetails->fmt == LVCFMT_RIGHT_TO_LEFT) { puiff = PUIFFDF_RIGHTTOLEFT; } TCHAR szTemp[MAX_PATH]; hr = SHFormatForDisplay(cle.shci.scid.fmtid, cle.shci.scid.pid, (PROPVARIANT*)&var, puiff, szTemp, ARRAYSIZE(szTemp)); if (SUCCEEDED(hr)) { hr = StringToStrRet(szTemp, &pDetails->str); } VariantClear(&var); break; } VariantClear(&var); } } // if we failed to find a value here return empty success so we don't // endlessly pester all column handlers for this column/item. if (S_OK != hr) { pDetails->str.uType = STRRET_CSTR; pDetails->str.cStr[0] = 0; hr = S_FALSE; } } } } else hr = E_NOTIMPL; // the bogus return value defview expects... } return hr; } HRESULT CFSFolder::_CompareExtendedProp(int iColumn, LPCIDFOLDER pidf1, LPCIDFOLDER pidf2) { HRESULT hr = _LoadColumnHandlers(); if (SUCCEEDED(hr)) { if ((DWORD)iColumn < _dwColCount) { COLUMNLISTENTRY cle; if (_FindColHandler(iColumn, 0, &cle)) { int iRet = CompareBySCID(this, &cle.shci.scid, (LPCITEMIDLIST)pidf1, (LPCITEMIDLIST)pidf2); hr = ResultFromShort(iRet); } } else { hr = E_FAIL; } } return hr; } HRESULT CFSFolder::GetDetailsOf(LPCITEMIDLIST pidl, UINT iColumn, SHELLDETAILS *pDetails) { LPCIDFOLDER pidf = _IsValidID(pidl); pDetails->str.uType = STRRET_CSTR; pDetails->str.cStr[0] = 0; if (iColumn >= ARRAYSIZE(c_fs_cols)) { return _ExtendedColumn(pidf, iColumn - ARRAYSIZE(c_fs_cols), pDetails); } if (!pidf) { return GetDetailsOfInfo(c_fs_cols, ARRAYSIZE(c_fs_cols), iColumn, pDetails); } TCHAR szTemp[MAX_PATH]; szTemp[0] = 0; switch (iColumn) { case FS_ICOL_NAME: _NormalDisplayName(pidf, szTemp, ARRAYSIZE(szTemp)); break; case FS_ICOL_SIZE: if (!_IsFolder(pidf)) { ULONGLONG cbSize = _Size(pidf); StrFormatKBSize(cbSize, szTemp, ARRAYSIZE(szTemp)); } break; case FS_ICOL_TYPE: _GetTypeNameBuf(pidf, szTemp, ARRAYSIZE(szTemp)); break; case FS_ICOL_WRITETIME: DosTimeToDateTimeString(pidf->dateModified, pidf->timeModified, szTemp, ARRAYSIZE(szTemp), pDetails->fmt & LVCFMT_DIRECTION_MASK); break; case FS_ICOL_CREATETIME: case FS_ICOL_ACCESSTIME: { WIN32_FIND_DATAW wfd; if (SUCCEEDED(_FindDataFromIDFolder(pidf, &wfd, FALSE))) { DWORD dwFlags = FDTF_DEFAULT; switch (pDetails->fmt) { case LVCFMT_LEFT_TO_RIGHT: dwFlags |= FDTF_LTRDATE; break; case LVCFMT_RIGHT_TO_LEFT: dwFlags |= FDTF_RTLDATE; break; } FILETIME ft = (iColumn == FS_ICOL_CREATETIME) ? wfd.ftCreationTime : wfd.ftLastAccessTime; SHFormatDateTime(&ft, &dwFlags, szTemp, ARRAYSIZE(szTemp)); } } break; case FS_ICOL_ATTRIB: BuildAttributeString(pidf->wAttrs, szTemp, ARRAYSIZE(szTemp)); break; case FS_ICOL_CSC_STATUS: LoadString(HINST_THISDLL, _IsOfflineCSC(pidf) ? IDS_CSC_STATUS_OFFLINE : IDS_CSC_STATUS_ONLINE, szTemp, ARRAYSIZE(szTemp)); break; } return StringToStrRet(szTemp, &pDetails->str); } HRESULT CFSFolder::_GetIntroText(LPCIDFOLDER pidf, WCHAR* pwszIntroText, UINT cchIntroText) { HRESULT hr = E_FAIL; TCHAR szPath[MAX_PATH]; if (SUCCEEDED(_GetPathForItem(pidf, szPath))) { // Keep the order in csidlIntroText and IntroTextCSIDLFolders, the same const int csidlIntroText[] = { CSIDL_STARTMENU, CSIDL_COMMON_DOCUMENTS, CSIDL_COMMON_PICTURES, CSIDL_COMMON_MUSIC }; UINT csidl = GetSpecialFolderID(szPath, csidlIntroText, ARRAYSIZE(csidlIntroText)); if (csidl != -1) { // Keep the order in csidlIntroText and IntroTextCSIDLFolders, the same static struct { UINT csidl; UINT resid; } IntroTextCSIDLFolders[] = { {CSIDL_STARTMENU, IDS_INTRO_STARTMENU}, {CSIDL_COMMON_DOCUMENTS, IDS_INTRO_SHAREDDOCS}, {CSIDL_COMMON_PICTURES, IDS_INTRO_SHAREDPICTURES}, {CSIDL_COMMON_MUSIC, IDS_INTRO_SHAREDMUSIC} }; UINT residIntroText = 0; for (int i = 0; i < ARRAYSIZE(IntroTextCSIDLFolders); i++) { if (IntroTextCSIDLFolders[i].csidl == csidl) { residIntroText = IntroTextCSIDLFolders[i].resid; break; } } if (residIntroText) { if (LoadString(HINST_THISDLL, residIntroText, pwszIntroText, cchIntroText)) { hr = S_OK; } } } } return hr; } DEFINE_SCID(SCID_HTMLINFOTIPFILE, PSGUID_MISC, PID_HTMLINFOTIPFILE); BOOL GetShellClassInfoHTMLInfoTipFile(LPCTSTR pszPath, LPTSTR pszBuffer, DWORD cchBuffer) { TCHAR szHTMLInfoTipFile[MAX_PATH]; BOOL fRet = GetShellClassInfo(pszPath, TEXT("HTMLInfoTipFile"), szHTMLInfoTipFile, ARRAYSIZE(szHTMLInfoTipFile)); if (fRet) { LPTSTR psz = szHTMLInfoTipFile; if (StrCmpNI(TEXT("file://"), psz, 7) == 0) // ARRAYSIZE(TEXT("file://")) { psz += 7; // ARRAYSIZE(TEXT("file://")) } PathCombine(psz, pszPath, psz); lstrcpyn(pszBuffer, psz, cchBuffer); } return fRet; } // These next functions are for the shell OM script support HRESULT CFSFolder::GetDetailsEx(LPCITEMIDLIST pidl, const SHCOLUMNID *pscid, VARIANT *pv) { BOOL fFound; HRESULT hr = AssocGetDetailsOfSCID(this, pidl, pscid, pv, &fFound); LPCIDFOLDER pidf = _IsValidID(pidl); if (FAILED(hr) && !fFound && pidf) { if (IsEqualSCID(*pscid, SCID_FINDDATA)) { WIN32_FIND_DATAW wfd; hr = _FindDataFromIDFolder(pidf, &wfd, TRUE); if (SUCCEEDED(hr)) { hr = InitVariantFromBuffer(pv, &wfd, sizeof(wfd)); } } else if (IsEqualSCID(*pscid, SCID_DESCRIPTIONID)) { SHDESCRIPTIONID did = {0}; switch (((SIL_GetType(pidl) & SHID_TYPEMASK) & ~(SHID_FS_UNICODE | SHID_FS_COMMONITEM)) | SHID_FS) { case SHID_FS_FILE: did.dwDescriptionId = SHDID_FS_FILE; break; case SHID_FS_DIRECTORY: did.dwDescriptionId = SHDID_FS_DIRECTORY; break; default: did.dwDescriptionId = SHDID_FS_OTHER; break; } _GetJunctionClsid(pidf, &did.clsid); hr = InitVariantFromBuffer(pv, &did, sizeof(did)); } else if (IsEqualSCID(*pscid, SCID_FolderIntroText)) { WCHAR wszIntroText[INFOTIPSIZE]; hr = _GetIntroText(pidf, wszIntroText, ARRAYSIZE(wszIntroText)); if (SUCCEEDED(hr)) { hr = InitVariantFromStr(pv, wszIntroText); } } else if (IsEqualSCID(*pscid, SCID_SIZE)) { TCHAR szMountPoint[MAX_PATH]; // In case we fail pv->ullVal = 0; pv->vt = VT_UI8; if (_GetMountingPointInfo(pidf, szMountPoint, ARRAYSIZE(szMountPoint))) { ULARGE_INTEGER uliFreeToCaller, uliTotal, uliTotalFree; if (SHGetDiskFreeSpaceExW(szMountPoint, &uliFreeToCaller, &uliTotal, &uliTotalFree)) { pv->ullVal = uliTotal.QuadPart; } } else { pv->ullVal = _Size(pidf); // note, size for folder is 0 pv->vt = VT_UI8; } hr = S_OK; } else if (IsEqualSCID(*pscid, SCID_FREESPACE)) { TCHAR szMountPoint[MAX_PATH]; if (_GetMountingPointInfo(pidf, szMountPoint, ARRAYSIZE(szMountPoint))) { ULARGE_INTEGER uliFreeToCaller, uliTotal, uliTotalFree; if (SHGetDiskFreeSpaceExW(szMountPoint, &uliFreeToCaller, &uliTotal, &uliTotalFree)) { pv->ullVal = uliFreeToCaller.QuadPart; pv->vt = VT_UI8; hr = S_OK; } } } else if (IsEqualSCID(*pscid, SCID_WRITETIME) || IsEqualSCID(*pscid, SCID_CREATETIME) || IsEqualSCID(*pscid, SCID_ACCESSTIME)) { WIN32_FIND_DATAW wfd; hr = _FindDataFromIDFolder(pidf, &wfd, FALSE); if (SUCCEEDED(hr)) { FILETIME ft; if (pscid->pid == PID_STG_WRITETIME) { ft = wfd.ftLastWriteTime; } else if (pscid->pid == PID_STG_CREATETIME) { ft = wfd.ftCreationTime; } else { ft = wfd.ftLastAccessTime; } hr = InitVariantFromFileTime(&ft, pv); } } else if (IsEqualSCID(*pscid, SCID_DIRECTORY)) { TCHAR szTemp[MAX_PATH]; hr = _GetPath(szTemp); if (SUCCEEDED(hr)) { hr = InitVariantFromStr(pv, szTemp); } } else if (IsEqualSCID(*pscid, SCID_ATTRIBUTES_DESCRIPTION)) { hr = _GetAttributesDescription(pidf, pv); } else if (IsEqualSCID(*pscid, SCID_LINKTARGET)) { hr = _GetLinkTarget(pidl, pv); } else if (IsEqualSCID(*pscid, SCID_CSC_STATUS)) { hr = _GetCSCStatus(pidf, pv); } else if ((IsEqualSCID(*pscid, SCID_Comment) || IsEqualSCID(*pscid, SCID_HTMLINFOTIPFILE)) && _IsSystemFolder(pidf)) { TCHAR szPath[MAX_PATH]; hr = _GetPathForItem(pidf, szPath); if (SUCCEEDED(hr)) { TCHAR szText[MAX_PATH]; if (IsEqualSCID(*pscid, SCID_Comment)) GetShellClassInfoInfoTip(szPath, szText, ARRAYSIZE(szText)); else GetShellClassInfoHTMLInfoTipFile(szPath, szText, ARRAYSIZE(szText)); hr = InitVariantFromStr(pv, szText); } } else if (IsEqualSCID(*pscid, SCID_COMPUTERNAME)) { hr = _GetComputerName(pidf, pv); } else if (IsEqualSCID(*pscid, SCID_NETWORKLOCATION)) { hr = _GetNetworkLocation(pidf, pv); } else // if (Column Handler) { int iCol = FindSCID(c_fs_cols, ARRAYSIZE(c_fs_cols), pscid); if (iCol >= 0) { SHELLDETAILS sd; hr = GetDetailsOf(pidl, iCol, &sd); if (SUCCEEDED(hr)) { hr = InitVariantFromStrRet(&sd.str, pidl, pv); } } else { hr = _LoadColumnHandlers(); if (SUCCEEDED(hr)) { hr = E_FAIL; for (int i = 0; i < DSA_GetItemCount(_hdsaColHandlers); i++) { COLUMNLISTENTRY *pcle = (COLUMNLISTENTRY *)DSA_GetItemPtr(_hdsaColHandlers, i); if (IsEqualSCID(*pscid, pcle->shci.scid)) { SHCOLUMNDATA shcd; hr = _InitColData(pidf, &shcd); if (SUCCEEDED(hr)) { hr = pcle->pcp->GetItemData(pscid, &shcd, pv); if (S_OK == hr) break; else if (SUCCEEDED(hr)) VariantClear(pv); } else break; } } } } } } return hr; } // GetDetailsEx() helper. HRESULT CFSFolder::_GetAttributesDescription(LPCIDFOLDER pidf, VARIANT *pv) { static WCHAR szR[32] = {0}; // read-only static WCHAR szH[32] = {0}; // hidden static WCHAR szS[32] = {0}; // system static WCHAR szC[32] = {0}; // compressed static WCHAR szE[32] = {0}; // encrypted static WCHAR szO[32] = {0}; // offline WCHAR szAttributes[256] = {0}; size_t cchAttributes = ARRAYSIZE(szAttributes); BOOL bIsFolder = _IsFolder(pidf); // // Initialize cached values once 'n only once. // if (!szR[0]) { ASSERT(!szH[0] && !szS[0] && !szC[0] && !szE[0] && !szO[0]); LoadString(HINST_THISDLL, IDS_ATTRIBUTE_READONLY, szR, ARRAYSIZE(szR)); LoadString(HINST_THISDLL, IDS_ATTRIBUTE_HIDDEN, szH, ARRAYSIZE(szH)); LoadString(HINST_THISDLL, IDS_ATTRIBUTE_SYSTEM, szS, ARRAYSIZE(szS)); LoadString(HINST_THISDLL, IDS_ATTRIBUTE_COMPRESSED, szC, ARRAYSIZE(szC)); LoadString(HINST_THISDLL, IDS_ATTRIBUTE_ENCRYPTED, szE, ARRAYSIZE(szE)); LoadString(HINST_THISDLL, IDS_ATTRIBUTE_OFFLINE, szO, ARRAYSIZE(szO)); } else { ASSERT(szH[0] && szS[0] && szC[0] && szE[0] && szO[0]); } // // Create attribute description string. // // read-only if ((pidf->wAttrs & FILE_ATTRIBUTE_READONLY) && !bIsFolder) _GetAttributesDescriptionBuilder(szAttributes, cchAttributes, szR); // hidden if (pidf->wAttrs & FILE_ATTRIBUTE_HIDDEN) _GetAttributesDescriptionBuilder(szAttributes, cchAttributes, szH); // system if ((pidf->wAttrs & FILE_ATTRIBUTE_SYSTEM) && !bIsFolder) _GetAttributesDescriptionBuilder(szAttributes, cchAttributes, szS); // archive // By design, archive is not exposed as an attribute description. It is // used by "backup applications" and in general is a loose convention no // one really cares about (chrisg). The decision to hide archive stems // from a desire to keep the Details pane free of useless gargabe. Note // that in Windows 2000, archive was not exposed through the web view. // compressed if (pidf->wAttrs & FILE_ATTRIBUTE_COMPRESSED) _GetAttributesDescriptionBuilder(szAttributes, cchAttributes, szC); // encrypted if (pidf->wAttrs & FILE_ATTRIBUTE_ENCRYPTED) _GetAttributesDescriptionBuilder(szAttributes, cchAttributes, szE); // offline if (pidf->wAttrs & FILE_ATTRIBUTE_OFFLINE) _GetAttributesDescriptionBuilder(szAttributes, cchAttributes, szO); return InitVariantFromStr(pv, szAttributes); } HRESULT CFSFolder::_GetAttributesDescriptionBuilder(LPWSTR szAttributes, size_t cchAttributes, LPWSTR szAttribute) { static WCHAR szDelimiter[4] = {0}; // Initialize cached delimiter once 'n only once. if (!szDelimiter[0]) { LoadString(HINST_THISDLL, IDS_COMMASPACE, szDelimiter, ARRAYSIZE(szDelimiter)); } // Build attribute description. if (!szAttributes[0]) { StrNCpy(szAttributes, szAttribute, cchAttributes); } else { StrCatBuff(szAttributes, szDelimiter, cchAttributes); StrCatBuff(szAttributes, szAttribute, cchAttributes); } return S_OK; } // GetDetailsEx() helper. HRESULT CFSFolder::_GetLinkTarget(LPCITEMIDLIST pidl, VARIANT *pv) { IShellLink *psl; HRESULT hr = GetUIObjectOf(NULL, 1, &pidl, IID_PPV_ARG_NULL(IShellLink, &psl)); if (SUCCEEDED(hr)) { LPITEMIDLIST pidlTarget; hr = psl->GetIDList(&pidlTarget); if (SUCCEEDED(hr)) { WCHAR szPath[MAX_PATH]; hr = SHGetNameAndFlags(pidlTarget, SHGDN_FORADDRESSBAR | SHGDN_FORPARSING, szPath, ARRAYSIZE(szPath), NULL); if (SUCCEEDED(hr)) hr = InitVariantFromStr(pv, szPath); ILFree(pidlTarget); } psl->Release(); } return hr; } // GetDetailsEx() helper. HRESULT CFSFolder::_GetNetworkLocation(LPCIDFOLDER pidf, VARIANT *pv) { LPCITEMIDLIST pidl = (LPCITEMIDLIST)pidf; IShellLink *psl; HRESULT hr = GetUIObjectOf(NULL, 1, &pidl, IID_PPV_ARG_NULL(IShellLink, &psl)); if (SUCCEEDED(hr)) { LPITEMIDLIST pidlTarget; hr = psl->GetIDList(&pidlTarget); if (SUCCEEDED(hr)) { TCHAR szPath[MAX_PATH]; hr = SHGetNameAndFlags(pidlTarget, SHGDN_FORPARSING, szPath, ARRAYSIZE(szPath), NULL); if (SUCCEEDED(hr)) { DWORD dwZone; hr = GetZoneFromUrl(szPath, NULL, &dwZone); if (SUCCEEDED(hr)) { TCHAR szBuffer[MAX_PATH]; switch (dwZone) { case URLZONE_LOCAL_MACHINE: case URLZONE_INTRANET: LoadString(g_hinst, IDS_NETLOC_LOCALNETWORK, szBuffer, ARRAYSIZE(szBuffer)); hr = InitVariantFromStr(pv, szBuffer); break; case URLZONE_INTERNET: LoadString(g_hinst, IDS_NETLOC_INTERNET, szBuffer, ARRAYSIZE(szBuffer)); hr = InitVariantFromStr(pv, szBuffer); break; default: hr = S_FALSE; break; } } } ILFree(pidlTarget); } psl->Release(); } return hr; } // GetDetailsEx() helper. HRESULT CFSFolder::_GetComputerName(LPCIDFOLDER pidf, VARIANT *pv) { LPCITEMIDLIST pidl = (LPCITEMIDLIST)pidf; IShellLink *psl; HRESULT hr = GetUIObjectOf(NULL, 1, &pidl, IID_PPV_ARG_NULL(IShellLink, &psl)); if (SUCCEEDED(hr)) { LPITEMIDLIST pidlTarget; hr = psl->GetIDList(&pidlTarget); if (SUCCEEDED(hr)) { WCHAR szPath[MAX_PATH]; if (SUCCEEDED(SHGetNameAndFlags(pidlTarget, SHGDN_FORPARSING, szPath, ARRAYSIZE(szPath), NULL))) { if (PathIsURL(szPath)) { TCHAR szServer[INTERNET_MAX_HOST_NAME_LENGTH + 1]; URL_COMPONENTS urlComps = {0}; urlComps.dwStructSize = sizeof(urlComps); urlComps.lpszHostName = szServer; urlComps.dwHostNameLength = ARRAYSIZE(szServer); BOOL fResult = InternetCrackUrl(szPath, 0, ICU_DECODE, &urlComps); if (fResult) { hr = InitVariantFromStr(pv, szServer); } else { hr = E_FAIL; } } else if (PathIsUNC(szPath)) { hr = _GetComputerName_FromPath(szPath, pv); } else { hr = E_FAIL; } } else { hr = E_FAIL; } ILFree(pidlTarget); } psl->Release(); } else { TCHAR szPath[MAX_PATH]; hr = _GetPath(szPath); if (SUCCEEDED(hr)) { hr = _GetComputerName_FromPath(szPath, pv); } } if (FAILED(hr)) { WCHAR sz[MAX_PATH]; LoadString(HINST_THISDLL, IDS_UNKNOWNGROUP, sz, ARRAYSIZE(sz)); hr = InitVariantFromStr(pv, sz); } return hr; } HRESULT CFSFolder::_GetComputerName_FromPath(LPCWSTR pszPath, VARIANT *pv) { HRESULT hr; TCHAR szPath[MAX_PATH]; lstrcpyn(szPath, pszPath, ARRAYSIZE(szPath)); PathStripToRoot(szPath); if (PathIsUNC(szPath)) { hr = _GetComputerName_FromUNC(szPath, pv); } else { CMountPoint* pMtPt = CMountPoint::GetMountPoint(szPath, FALSE); if (pMtPt) { if (pMtPt->IsRemote()) { WCHAR szRemotePath[MAX_PATH]; hr = pMtPt->GetRemotePath(szRemotePath, ARRAYSIZE(szRemotePath)); if (SUCCEEDED(hr)) { hr = _GetComputerName_FromPath(szRemotePath, pv); } } else { WCHAR sz[MAX_PATH]; LoadString(HINST_THISDLL, IDS_THISCOMPUTERGROUP, sz, ARRAYSIZE(sz)); hr = InitVariantFromStr(pv, sz); } pMtPt->Release(); } else { hr = E_OUTOFMEMORY; } } return hr; } HRESULT CFSFolder::_GetComputerName_FromUNC(LPWSTR pszPath, VARIANT *pv) { // strip to "\\server" LPWSTR psz = pszPath; while (*psz && *psz==L'\\') psz++; while (*psz && *psz!=L'\\') psz++; *psz = NULL; LPITEMIDLIST pidl; HRESULT hr = SHParseDisplayName(pszPath, NULL, &pidl, 0, NULL); if (SUCCEEDED(hr)) { WCHAR szName[MAX_PATH]; hr = SHGetNameAndFlagsW(pidl, SHGDN_INFOLDER, szName, ARRAYSIZE(szName), NULL); if (SUCCEEDED(hr)) { hr = InitVariantFromStr(pv, szName); } ILFree(pidl); } return hr; } // GetDetailsEx() helper. HRESULT CFSFolder::_GetCSCStatus(LPCIDFOLDER pidf, VARIANT *pv) { HRESULT hr; // Note: // Only display the status in the Details task pane if it is "Offline". if (_IsOfflineCSC(pidf)) { WCHAR wszStatus[MAX_PATH]; if (LoadString(HINST_THISDLL, IDS_CSC_STATUS_OFFLINE, wszStatus, ARRAYSIZE(wszStatus))) hr = InitVariantFromStr(pv, wszStatus); else hr = HRESULT_FROM_WIN32(GetLastError()); } else { VariantInit(pv); pv->vt = VT_NULL; hr = S_OK; } return hr; } HRESULT CFSFolder::GetDefaultColumn(DWORD dwRes, ULONG *pSort, ULONG *pDisplay) { return E_NOTIMPL; } #define FVCBFT_MUSICFOLDER(ft) (FVCBFT_MUSIC == ft || FVCBFT_MYMUSIC == ft || FVCBFT_MUSICARTIST == ft || FVCBFT_MUSICALBUM == ft) BOOL CFSFolder::_ShouldNotShowColumn(UINT iColumn) { BOOL fRet = FALSE; // show by default if (FVCBFT_MUSICFOLDER(_nFolderType)) { fRet = (iColumn == FS_ICOL_WRITETIME); // hide this one in the music case } return fRet; } BOOL CFSFolder::_ShouldShowExtendedColumn(const SHCOLUMNID* pscid) { BOOL fRet; switch(_nFolderType) { case FVCBFT_PICTURES: case FVCBFT_MYPICTURES: case FVCBFT_PHOTOALBUM: fRet = (IsEqualSCID(*pscid, SCID_WhenTaken) || IsEqualSCID(*pscid, SCID_ImageDimensions)); break; case FVCBFT_MUSIC: case FVCBFT_MYMUSIC: case FVCBFT_MUSICARTIST: case FVCBFT_MUSICALBUM: fRet = (IsEqualSCID(*pscid, SCID_MUSIC_Artist) || IsEqualSCID(*pscid, SCID_MUSIC_Year) || IsEqualSCID(*pscid, SCID_MUSIC_Album) || IsEqualSCID(*pscid, SCID_MUSIC_Track) || IsEqualSCID(*pscid, SCID_AUDIO_Duration)); break; case FVCBFT_VIDEOS: case FVCBFT_MYVIDEOS: case FVCBFT_VIDEOALBUM: fRet = (IsEqualSCID(*pscid, SCID_AUDIO_Duration) || IsEqualSCID(*pscid, SCID_ImageDimensions)); break; default: fRet = FALSE; break; } return fRet; } HRESULT CFSFolder::GetDefaultColumnState(UINT iColumn, DWORD *pdwState) { HRESULT hr = S_OK; *pdwState = 0; if (iColumn < ARRAYSIZE(c_fs_cols)) { *pdwState = c_fs_cols[iColumn].csFlags; if (_ShouldNotShowColumn(iColumn)) { *pdwState &= ~SHCOLSTATE_ONBYDEFAULT; // flip stuff off } } else { iColumn -= ARRAYSIZE(c_fs_cols); hr = _LoadColumnHandlers(); if (SUCCEEDED(hr)) { hr = E_INVALIDARG; if (iColumn < _dwColCount) { COLUMNLISTENTRY cle; if (_FindColHandler(iColumn, 0, &cle)) { *pdwState |= (cle.shci.csFlags | SHCOLSTATE_EXTENDED | SHCOLSTATE_SLOW); if (_ShouldShowExtendedColumn(&cle.shci.scid)) { *pdwState |= SHCOLSTATE_ONBYDEFAULT; } else { *pdwState &= ~SHCOLSTATE_ONBYDEFAULT; // strip this one } hr = S_OK; } } } } return hr; } HRESULT CFSFolder::MapColumnToSCID(UINT iColumn, SHCOLUMNID *pscid) { HRESULT hr = MapColumnToSCIDImpl(c_fs_cols, ARRAYSIZE(c_fs_cols), iColumn, pscid); if (hr != S_OK) { COLUMNLISTENTRY cle; if (SUCCEEDED(_LoadColumnHandlers())) { iColumn -= ARRAYSIZE(c_fs_cols); if (_FindColHandler(iColumn, 0, &cle)) { *pscid = cle.shci.scid; hr = S_OK; } } } return hr; } HRESULT CFSFolder::_MapSCIDToColumn(const SHCOLUMNID* pscid, UINT* puCol) { HRESULT hr; int iCol = FindSCID(c_fs_cols, ARRAYSIZE(c_fs_cols), pscid); if (iCol >= 0) { *puCol = iCol; hr = S_OK; } else { hr = _LoadColumnHandlers(); if (SUCCEEDED(hr)) { hr = E_FAIL; for (int i = 0; i < DSA_GetItemCount(_hdsaColHandlers); i++) { COLUMNLISTENTRY *pcle = (COLUMNLISTENTRY *)DSA_GetItemPtr(_hdsaColHandlers, i); if (IsEqualSCID(*pscid, pcle->shci.scid)) { *puCol = pcle->iColumnId; hr = S_OK; break; } } } } return hr; } // // N ways to get a clasid for an item // BOOL CFSFolder::_GetBindCLSID(IBindCtx *pbc, LPCIDFOLDER pidf, CLSID *pclsid) { CFileSysItemString fsi(pidf); DWORD dwClassFlags = fsi.ClassFlags(FALSE); if (dwClassFlags & SHCF_IS_DOCOBJECT) { *pclsid = CLSID_CDocObjectFolder; } else if (fsi.GetJunctionClsid(pclsid, TRUE)) { // *pclsid has the value // HACK: CLSID_Briefcase is use to identify the briefcase // but it's InProcServer is syncui.dll. we need to map that CLSID // to the object implemented in shell32 (CLSID_BriefcaseFolder) // ZEKELTODO - why isnt this a COM "TreatAs"? if (IsEqualCLSID(*pclsid, CLSID_Briefcase)) *pclsid = CLSID_BriefcaseFolder; } else if (!IsEqualCLSID(CLSID_NULL, _clsidBind)) { *pclsid = _clsidBind; // briefcase forces all children this way } else { return FALSE; // do normal binding } // TRUE -> special binding, FALSE -> normal file system binding return !SHSkipJunctionBinding(pbc, pclsid); } // initalize shell folder handlers // in: // pidf multi level file system pidl // // in/out: // *ppunk // // note: on failure this frees *ppunk HRESULT CFSFolder::_InitFolder(IBindCtx *pbc, LPCIDFOLDER pidf, IUnknown **ppunk) { ASSERT(_FindJunctionNext(pidf) == NULL); // no extra goo please LPITEMIDLIST pidlInit; HRESULT hr = SHILCombine(_pidl, (LPITEMIDLIST)pidf, &pidlInit); if (SUCCEEDED(hr)) { IPersistFolder3 *ppf3; hr = (*ppunk)->QueryInterface(IID_PPV_ARG(IPersistFolder3, &ppf3)); if (SUCCEEDED(hr)) { PERSIST_FOLDER_TARGET_INFO pfti = {0}; if (_csidlTrack >= 0) { // SHGetSpecialFolderlocation will return error if the target // doesn't exist (which is good, since that means there's // nothing to bind to). LPITEMIDLIST pidl; hr = SHGetSpecialFolderLocation(NULL, _csidlTrack, &pidl); if (SUCCEEDED(hr)) { hr = SHILCombine(pidl, (LPITEMIDLIST)pidf, &pfti.pidlTargetFolder); ILFree(pidl); } } else if (_pidlTarget) hr = SHILCombine(_pidlTarget, (LPITEMIDLIST)pidf, &pfti.pidlTargetFolder); if (SUCCEEDED(hr)) { hr = _GetPathForItem(pidf, pfti.szTargetParsingName); if (SUCCEEDED(hr)) { if (_pszNetProvider) SHTCharToUnicode(_pszNetProvider, pfti.szNetworkProvider, ARRAYSIZE(pfti.szNetworkProvider)); pfti.dwAttributes = _FindLastID(pidf)->wAttrs; pfti.csidl = -1; hr = ppf3->InitializeEx(pbc, pidlInit, &pfti); } ILFree(pfti.pidlTargetFolder); } ppf3->Release(); } else { IPersistFolder *ppf; hr = (*ppunk)->QueryInterface(IID_PPV_ARG(IPersistFolder, &ppf)); if (SUCCEEDED(hr)) { hr = ppf->Initialize(pidlInit); ppf->Release(); if (hr == E_NOTIMPL) // map E_NOTIMPL into success, the folder does not care hr = S_OK; } } ILFree(pidlInit); } if (FAILED(hr)) { ((IUnknown *)*ppunk)->Release(); *ppunk = NULL; } return hr; } HRESULT CFSFolder::_InitStgFolder(LPCIDFOLDER pidf, LPCWSTR wszPath, DWORD grfMode, REFIID riid, void **ppv) { IStorage *pstg; // pick up the storage from the pidl. // TODO: make this work on stuff other than docfiles HRESULT hr = StgGetStorageFromFile(wszPath, grfMode, &pstg); if (SUCCEEDED(hr)) { hr = CStgFolder_CreateInstance(NULL, riid, ppv); if (SUCCEEDED(hr)) { // we need to init CStgFolder with an IStorage that it // wraps, so pass it in through the bind context. IBindCtx *pbc; hr = CreateBindCtx(0, &pbc); if (SUCCEEDED(hr)) { hr = pbc->RegisterObjectParam(STGSTR_STGTOBIND, pstg); if (SUCCEEDED(hr)) hr = _InitFolder(pbc, pidf, (IUnknown **)ppv); pbc->Release(); } if (FAILED(hr)) ATOMICRELEASE(*((IUnknown **)ppv)); } pstg->Release(); } return hr; } CFSFolderPropertyBag::CFSFolderPropertyBag(CFSFolder *pFSFolder, DWORD grfMode) : _cRef(1), _grfMode(grfMode), _pFSFolder(pFSFolder) { _pFSFolder->AddRef(); } CFSFolderPropertyBag::~CFSFolderPropertyBag() { _pFSFolder->Release(); // Release all the property bags for (int i = 0; i < ARRAYSIZE(_pPropertyBags); i++) { if (_pPropertyBags[i]) { _pPropertyBags[i]->Release(); } } } STDMETHODIMP CFSFolderPropertyBag::QueryInterface(REFIID riid, void **ppv) { static const QITAB qit[] = { QITABENT(CFSFolderPropertyBag, IPropertyBag), // IID_IPropertyBag { 0 }, }; return QISearch(this, qit, riid, ppv); } STDMETHODIMP_(ULONG) CFSFolderPropertyBag::AddRef() { return InterlockedIncrement(&_cRef); } STDMETHODIMP_(ULONG) CFSFolderPropertyBag::Release() { if (InterlockedDecrement(&_cRef)) return _cRef; delete this; return 0; } HRESULT CFSFolderPropertyBag::_Init(LPCIDFOLDER pidfLast) { TCHAR szFolderPath[MAX_PATH]; HRESULT hr = _pFSFolder->_GetPathForItem(pidfLast, szFolderPath); if (SUCCEEDED(hr)) { TCHAR szPath[MAX_PATH]; if (_GetIniPath((_grfMode == STGM_WRITE) || (_grfMode == STGM_READWRITE), szFolderPath, NULL, szPath)) { // This is a customized folder (likely). // Get an IPropertyBag on it's desktop.ini. if (SUCCEEDED(SHCreatePropertyBagOnProfileSection(szPath, STRINI_CLASSINFO, _grfMode, IID_PPV_ARG(IPropertyBag, &_pPropertyBags[INDEX_PROPERTYBAG_DESKTOPINI])))) { TCHAR szFolderType[128]; if (SUCCEEDED(SHPropertyBag_ReadStr(_pPropertyBags[INDEX_PROPERTYBAG_DESKTOPINI], L"FolderType", szFolderType, ARRAYSIZE(szFolderType)))) { TCHAR szRegPath[256]; StrCpyN(szRegPath, REGSTR_PATH_EXPLORER L"\\FolderClasses\\", ARRAYSIZE(szRegPath)); StrCatN(szRegPath, szFolderType, ARRAYSIZE(szRegPath)); SHCreatePropertyBagOnRegKey(HKEY_CURRENT_USER, szRegPath, _grfMode, IID_PPV_ARG(IPropertyBag, &_pPropertyBags[INDEX_PROPERTYBAG_HKCU])); SHCreatePropertyBagOnRegKey(HKEY_LOCAL_MACHINE, szRegPath, _grfMode, IID_PPV_ARG(IPropertyBag, &_pPropertyBags[INDEX_PROPERTYBAG_HKLM])); } } } else { hr = E_FAIL; } } return hr; } HRESULT CFSFolderPropertyBag::Read(LPCOLESTR pszPropName, VARIANT *pvar, IErrorLog *pErrorLog) { // We first try reading HKCU\RegKeySpecifiedInDesktopIniForTheFolder, // then HKLM\RegKeySpecifiedInDesktopIniForTheFolder and finally // the desktop.ini HRESULT hr = E_FAIL; for (int i = 0; FAILED(hr) && (i < ARRAYSIZE(_pPropertyBags)); i++) { if (_pPropertyBags[i]) { hr = _pPropertyBags[i]->Read(pszPropName, pvar, pErrorLog); } } return hr; } HRESULT CFSFolderPropertyBag::Write(LPCOLESTR pszPropName, VARIANT *pvar) { // We first try writing to HKCU\RegKeySpecifiedInDesktopIniForTheFolder, // then to HKLM\RegKeySpecifiedInDesktopIniForTheFolder and finally // to desktop.ini HRESULT hr = E_FAIL; for (int i = 0; FAILED(hr) && (i < ARRAYSIZE(_pPropertyBags)); i++) { if (_pPropertyBags[i]) { hr = _pPropertyBags[i]->Write(pszPropName, pvar); } } return hr; } // pidfLast can be NULL, if so create the bag on this folder HRESULT CFSFolder::_CreateFolderPropertyBag(DWORD grfMode, LPCIDFOLDER pidfLast, REFIID riid, void **ppv) { *ppv = NULL; HRESULT hr; CFSFolderPropertyBag *pbag = new CFSFolderPropertyBag(this, grfMode); if (pbag) { hr = pbag->_Init(pidfLast); if (SUCCEEDED(hr)) { hr = pbag->QueryInterface(riid, ppv); } pbag->Release(); } else { hr = E_OUTOFMEMORY; } return hr; } // // pidfLast and pszIniPath can be NULL. // If not NULL, pidfLast is an IN param - specifies the relative pidl of a subfolder // inside the CFSFolder object. // If not NULL, pszIniPath is an OUT param (pointer to a buffer atleast MAX_PATH long) // - receives the path to desktop.ini // BOOL CFSFolder::_CheckDefaultIni(LPCIDFOLDER pidfLast, LPTSTR pszIniPath) { BOOL fForceIni = FALSE; TCHAR szPath[MAX_PATH]; if (!pszIniPath) pszIniPath = szPath; HRESULT hr = _GetPathForItem(pidfLast, pszIniPath); if (SUCCEEDED(hr) && PathIsRoot(pszIniPath)) { // Desktop.ini has to be checked for the root folders // even if the RO or SYSTEM bits are not set on them fForceIni = TRUE; } else { UINT csidl; if (!pidfLast) { csidl = _GetCSIDL(); // Get the cached value for the current folder } else { // For subfolders, we don't have any cached values. So, compute. _csidl = GetSpecialFolderID(pszIniPath, c_csidlSpecial, ARRAYSIZE(c_csidlSpecial)); } switch (csidl) { // Desktop.ini has to be checked for the following special folders // even if the RO or SYSTEM bits are not set on them case CSIDL_SYSTEM: case CSIDL_WINDOWS: case CSIDL_PERSONAL: fForceIni = TRUE; break; } } if (!fForceIni) { // Is the RO or SYSTEM bit set? fForceIni = (_Attributes() & (FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_SYSTEM)); } // Append desktop.ini to the path if (SUCCEEDED(hr)) { PathAppend(pszIniPath, c_szDesktopIni); } return fForceIni; } LPCTSTR CFSFolder::_BindHandlerName(REFIID riid) { LPCTSTR pszHandler = NULL; if (IsEqualIID(riid, IID_IPropertySetStorage)) pszHandler = TEXT("PropertyHandler"); else if (IsEqualIID(riid, IID_IStorage)) pszHandler = TEXT("StorageHandler"); return pszHandler; } const CLSID CLSID_CTextIFilter = { 0xc1243ca0, 0xbf96, 0x11cd, { 0xb5, 0x79, 0x08, 0x00, 0x2b, 0x30, 0xbf, 0xeb }}; HRESULT LoadIFilterWithTextFallback( WCHAR const *pwcsPath, IUnknown *pUnkOuter, void **ppIUnk) { HRESULT hr = LoadIFilter(pwcsPath, pUnkOuter, ppIUnk); if (FAILED(hr)) { DWORD dwFilterUnknown = 0; DWORD cb = sizeof(dwFilterUnknown); SHGetValue(HKEY_LOCAL_MACHINE, TEXT("SYSTEM\\CurrentControlSet\\Control\\ContentIndex"), TEXT("FilterFilesWithUnknownExtensions"), NULL, &dwFilterUnknown, &cb); if (dwFilterUnknown != 0) { IPersistFile *ppf; hr = CoCreateInstance(CLSID_CTextIFilter, pUnkOuter, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IPersistFile, &ppf)); if (SUCCEEDED(hr)) { hr = ppf->Load(pwcsPath, STGM_READ); if (SUCCEEDED(hr)) { hr = ppf->QueryInterface(IID_IFilter, ppIUnk); } ppf->Release(); } } } return hr; } // pidf - multi level file system only item HRESULT CFSFolder::_Bind(LPBC pbc, LPCIDFOLDER pidf, REFIID riid, void **ppv) { ASSERT(_FindJunctionNext(pidf) == NULL); // no extra non file sys goo please *ppv = NULL; HRESULT hr; CLSID clsid; LPCIDFOLDER pidfLast = _FindLastID(pidf); if (_GetBindCLSID(pbc, pidfLast, &clsid)) { hr = SHExtCoCreateInstance(NULL, &clsid, NULL, riid, ppv); if (SUCCEEDED(hr)) hr = _InitFolder(pbc, pidf, (IUnknown **)ppv); if (FAILED(hr) && (E_NOINTERFACE != hr) && _IsFolder(pidfLast)) { // the IShellFolder extension failed to load (might not be installed // on this machine), so check if we should fall back to default to CFSFolder UINT dwFlags; if (_GetFolderFlags(pidf, &dwFlags) && (dwFlags & GFF_DEFAULT_TO_FS)) { hr = CFSFolder_CreateInstance(NULL, riid, ppv); if (SUCCEEDED(hr)) hr = _InitFolder(pbc, pidf, (IUnknown **)ppv); } } } else if (_IsFolder(pidfLast) || _IsSimpleID(pidfLast)) { hr = CFSFolder_CreateInstance(NULL, riid, ppv); if (SUCCEEDED(hr)) hr = _InitFolder(pbc, pidf, (IUnknown **)ppv); } else hr = E_FAIL; if (FAILED(hr)) { // this handler has a string version DWORD grfMode = BindCtx_GetMode(pbc, STGM_READ | STGM_SHARE_DENY_WRITE); LPCTSTR pszHandler = _BindHandlerName(riid); hr = _LoadHandler(pidf, grfMode, pszHandler, riid, ppv); if (FAILED(hr)) { WCHAR wszPath[MAX_PATH]; if (SUCCEEDED(_GetPathForItem(pidf, wszPath))) { if (IsEqualIID(riid, IID_IStream) && _IsFile(pidfLast)) { hr = SHCreateStreamOnFileEx(wszPath, grfMode, FILE_ATTRIBUTE_NORMAL, FALSE, NULL, (IStream **)ppv); } else if (IsEqualIID(riid, IID_IPropertyBag) && _IsFolder(pidfLast)) { hr = _CreateFolderPropertyBag(grfMode, pidf, riid, ppv); } else if (IsEqualIID(riid, IID_IPropertySetStorage)) { // this is questionable at best. the caller // should be filtering offline files, not this code. // legacy support, I don't think anyone depends on this // avoid offline files... if (FILE_ATTRIBUTE_OFFLINE & pidf->wAttrs) hr = STG_E_INVALIDFUNCTION; else { hr = StgOpenStorageEx(wszPath, grfMode, STGFMT_ANY, 0, NULL, NULL, riid, ppv); } } else if (IsEqualIID(riid, IID_IStorage)) { hr = _InitStgFolder(pidf, wszPath, grfMode, riid, ppv); } else if (IsEqualIID(riid, IID_IMoniker)) { hr = CreateFileMoniker(wszPath, (IMoniker **)ppv); } else if (IsEqualIID(riid, IID_IFilter)) { hr = LoadIFilterWithTextFallback(wszPath, NULL, ppv); } } } } ASSERT((SUCCEEDED(hr) && *ppv) || (FAILED(hr) && (NULL == *ppv))); // Assert hr is consistent w/out param. return hr; } // returns: // *ppidfBind - multi level file system pidl part (must free this on S_OK return) // *ppidlRight - non file system part of pidl, continue bind down to this // // S_OK // *ppidfBind needs to be freed // S_FALSE // pidf is a multi level file system only, bind to him // FAILED() out of meory errors HRESULT CFSFolder::_GetJunctionForBind(LPCIDFOLDER pidf, LPIDFOLDER *ppidfBind, LPCITEMIDLIST *ppidlRight) { *ppidfBind = NULL; *ppidlRight = _FindJunctionNext(pidf); if (*ppidlRight) { *ppidfBind = (LPIDFOLDER)ILClone((LPITEMIDLIST)pidf); if (*ppidfBind) { // remove the part below the junction point _ILSkip(*ppidfBind, (ULONG)((ULONG_PTR)*ppidlRight - (ULONG_PTR)pidf))->mkid.cb = 0; return S_OK; } return E_OUTOFMEMORY; } return S_FALSE; // nothing interesting } HRESULT CFSFolder::GetIconOf(LPCITEMIDLIST pidl, UINT flags, int *piIndex) { LPCIDFOLDER pidf = _IsValidID(pidl); if (pidf) { CFileSysItemString fsi(pidf); DWORD dwFlags; int iIcon = -1; // WARNING: don't include junctions (_IsFileFolder(pidf)) // so junctions like briefcase get their own cusotm icon. // if (_IsFileFolder(pidf)) { TCHAR szMountPoint[MAX_PATH]; TCHAR szModule[MAX_PATH]; iIcon = II_FOLDER; if (_GetMountingPointInfo(pidf, szMountPoint, ARRAYSIZE(szMountPoint))) { iIcon = GetMountedVolumeIcon(szMountPoint, szModule, ARRAYSIZE(szModule)); *piIndex = Shell_GetCachedImageIndex(szModule[0] ? szModule : c_szShell32Dll, iIcon, 0); return S_OK; } else { if (!_IsSystemFolder(pidf) && (_GetCSIDL() == CSIDL_NORMAL)) { if (flags & GIL_OPENICON) iIcon = II_FOLDEROPEN; else iIcon = II_FOLDER; *piIndex = Shell_GetCachedImageIndex(c_szShell32Dll, iIcon, 0); return S_OK; } iIcon = II_FOLDER; dwFlags = SHCF_ICON_PERINSTANCE; } } else dwFlags = fsi.ClassFlags(TRUE); // the icon is per-instance, try to look it up if (dwFlags & SHCF_ICON_PERINSTANCE) { TCHAR szFullPath[MAX_PATH]; DWORD uid = _GetUID(pidf); // get a unique identifier for this file. if (uid == 0) return S_FALSE; if (FAILED(_GetPathForItem(pidf, szFullPath))) { // fall back to the relative name if we can't get the full path lstrcpyn(szFullPath, fsi.FSName(), ARRAYSIZE(szFullPath)); } *piIndex = LookupIconIndex(szFullPath, uid, flags | GIL_NOTFILENAME); if (*piIndex != -1) return S_OK; // async extract (GIL_ASYNC) support // // we cant find the icon in the icon cache, we need to do real work // to get the icon. if the caller specified GIL_ASYNC // dont do the work, return E_PENDING forcing the caller to call // back later to get the real icon. // // when returing E_PENDING we must fill in a default icon index if (flags & GIL_ASYNC) { // come up with a default icon and return E_PENDING if (_IsFolder(pidf)) iIcon = II_FOLDER; else if (!(dwFlags & SHCF_HAS_ICONHANDLER) && PathIsExe(fsi.FSName())) iIcon = II_APPLICATION; else iIcon = II_DOCNOASSOC; *piIndex = Shell_GetCachedImageIndex(c_szShell32Dll, iIcon, 0); TraceMsg(TF_IMAGE, "Shell_GetCachedImageIndex(%d) returned = %d", iIcon, *piIndex); return E_PENDING; // we will be called back later for the real one } // If this is a folder, see if this folder has Per-Instance folder icon // we do this here because it's too expensive to open a desktop.ini // file and see what's in there. Most of the cases we will just hit // the above cases if (_IsSystemFolder(pidf)) { if (!_GetFolderIconPath(pidf, NULL, 0, NULL)) { // Note: the iIcon value has already been computed at the start of this funciton ASSERT(iIcon != -1); *piIndex = Shell_GetCachedImageIndex(c_szShell32Dll, iIcon, 0); return S_OK; } } // // look up icon using IExtractIcon, this will load handler iff needed // by calling ::GetUIObjectOf // IShellFolder *psf; HRESULT hr = QueryInterface(IID_PPV_ARG(IShellFolder, &psf)); if (SUCCEEDED(hr)) { hr = SHGetIconFromPIDL(psf, NULL, (LPCITEMIDLIST)pidf, flags, piIndex); psf->Release(); } // // remember this perinstance icon in the cache so we dont // need to load the handler again. // // SHGetIconFromPIDL will always return a valid image index // (it may default to a standard one) but it will fail // if the file cant be accessed or some other sort of error. // we dont want to cache in this case. // if (*piIndex != -1 && SUCCEEDED(hr) && (dwFlags & SHCF_HAS_ICONHANDLER)) { int iIndexRetry; ENTERCRITICAL; // // Inside the critical section, make sure the icon isn't already // loaded, and if its not, then add it. // iIndexRetry = LookupIconIndex(szFullPath, uid, flags | GIL_NOTFILENAME); if (iIndexRetry == -1) { AddToIconTable(szFullPath, uid, flags | GIL_NOTFILENAME, *piIndex); } LEAVECRITICAL; } return *piIndex == -1 ? S_FALSE : S_OK; } // icon is per-class dwFlags has the image index *piIndex = (dwFlags & SHCF_ICON_INDEX); return S_OK; } else { ASSERT(ILIsEmpty(pidl) || SIL_GetType(pidl) == SHID_ROOT_REGITEM); // regitems gives us these return S_FALSE; } } HANDLE g_hOverlayMgrCounter = NULL; // Global count of Overlay Manager changes. int g_lOverlayMgrPerProcessCount = 0; // Per process count of Overlay Manager changes. // // Use this function to obtain address of the singleton icon overlay manager. // If the function succeeds, caller is responsible for calling Release() through // the returned interface pointer. // The function ensures that the manager is initialized and up to date. // STDAPI GetIconOverlayManager(IShellIconOverlayManager **ppsiom) { HRESULT hr = E_FAIL; if (IconOverlayManagerInit()) { // // Is a critsec for g_psiom required here you ask? // // No. The first call to IconOverlayInit in any process creates // the overlay manager object and initializes g_psiom. This creation // contributes 1 to the object's ref count. Subsequent calls to // GetIconOverlayManager add to the ref count and the caller is // responsible for decrementing the count through Release(). // The original ref count of 1 is not removed until // IconOverlayManagerTerminate is called which happens only // during PROCESS_DETACH. Therefore, the manager referenced by g_psiom // in this code block will always be valid and a critsec is not // required. // // // ID for the global overlay manager counter. // static const GUID GUID_Counter = { /* 090851a5-eb96-11d2-8be4-00c04fa31a66 */ 0x090851a5, 0xeb96, 0x11d2, {0x8b, 0xe4, 0x00, 0xc0, 0x4f, 0xa3, 0x1a, 0x66} }; g_psiom->AddRef(); HANDLE hCounter = SHGetCachedGlobalCounter(&g_hOverlayMgrCounter, &GUID_Counter); long lGlobalCount = SHGlobalCounterGetValue(hCounter); if (lGlobalCount != g_lOverlayMgrPerProcessCount) { // // Per-process counter is out of sync with the global counter. // This means someone called SHLoadNonloadedIconOverlayIdentifiers // so we must load any non-loaded identifiers from the registry. // g_psiom->LoadNonloadedOverlayIdentifiers(); g_lOverlayMgrPerProcessCount = lGlobalCount; } *ppsiom = g_psiom; hr = S_OK; } return hr; } BOOL IconOverlayManagerInit() { if (!g_psiom) { IShellIconOverlayManager* psiom; if (SUCCEEDED(SHCoCreateInstance(NULL, &CLSID_CFSIconOverlayManager, NULL, IID_PPV_ARG(IShellIconOverlayManager, &psiom)))) { if (SHInterlockedCompareExchange((void **)&g_psiom, psiom, 0)) psiom->Release(); } } return BOOLFROMPTR(g_psiom); } void IconOverlayManagerTerminate() { ASSERTDLLENTRY; // does not require a critical section IShellIconOverlayManager *psiom = (IShellIconOverlayManager *)InterlockedExchangePointer((void **)&g_psiom, 0); if (psiom) psiom->Release(); if (NULL != g_hOverlayMgrCounter) { CloseHandle(g_hOverlayMgrCounter); g_hOverlayMgrCounter = NULL; } } STDAPI SHLoadNonloadedIconOverlayIdentifiers(void) { // // This will cause the next call GetIconOverlayManager() call in each process // to load any non-loaded icon overlay identifiers. // if (g_hOverlayMgrCounter) SHGlobalCounterIncrement(g_hOverlayMgrCounter); return S_OK; } HRESULT CFSFolder::_GetOverlayInfo(LPCITEMIDLIST pidl, int * pIndex, DWORD dwFlags) { HRESULT hr = E_FAIL; LPCIDFOLDER pidf = _IsValidID(pidl); *pIndex = 0; if (!pidf) { ASSERT(SIL_GetType(pidl) != SHID_ROOT_REGITEM); // CRegFolder should have handled it return S_FALSE; } ASSERT(pidl == ILFindLastID(pidl)); if (IconOverlayManagerInit()) { int iReservedID = -1; WCHAR wszPath[MAX_PATH]; hr = _GetPathForItem(pidf, wszPath); if (SUCCEEDED(hr)) { IShellIconOverlayManager *psiom; // The order of the "if" statements here is significant if (_IsFile(pidf) && (_GetClassFlags(pidf) & SHCF_IS_LINK)) iReservedID = SIOM_RESERVED_LINK; else { USES_CONVERSION; LPCTSTR szPath = W2CT(wszPath); if (_IsFolder(pidf) && (IsShared(szPath, FALSE))) iReservedID = SIOM_RESERVED_SHARED; else if (FILE_ATTRIBUTE_OFFLINE & pidf->wAttrs) iReservedID = SIOM_RESERVED_SLOWFILE; } hr = GetIconOverlayManager(&psiom); if (SUCCEEDED(hr)) { if (iReservedID != -1) hr = psiom->GetReservedOverlayInfo(wszPath, pidf->wAttrs, pIndex, dwFlags, iReservedID); else hr = psiom->GetFileOverlayInfo(wszPath, pidf->wAttrs, pIndex, dwFlags); psiom->Release(); } } } return hr; } HRESULT CFSFolder::GetOverlayIndex(LPCITEMIDLIST pidl, int * pIndex) { HRESULT hr = E_INVALIDARG; ASSERT(pIndex); if (pIndex) hr = (*pIndex == OI_ASYNC) ? E_PENDING : _GetOverlayInfo(pidl, pIndex, SIOM_OVERLAYINDEX); return hr; } HRESULT CFSFolder::GetOverlayIconIndex(LPCITEMIDLIST pidl, int * pIconIndex) { return _GetOverlayInfo(pidl, pIconIndex, SIOM_ICONINDEX); } // CFSFolder : IPersist, IPersistFolder, IPersistFolder2, IPersistFolderAlias Members HRESULT CFSFolder::GetClassID(CLSID *pclsid) { if (!IsEqualCLSID(_clsidBind, CLSID_NULL)) { *pclsid = _clsidBind; } else { *pclsid = CLSID_ShellFSFolder; } return S_OK; } HRESULT CFSFolder::Initialize(LPCITEMIDLIST pidl) { _Reset(); return SHILClone(pidl, &_pidl); } HRESULT CFSFolder::GetCurFolder(LPITEMIDLIST *ppidl) { return GetCurFolderImpl(_pidl, ppidl); } LPTSTR StrDupUnicode(const WCHAR *pwsz) { if (*pwsz) { USES_CONVERSION; return StrDup(W2CT(pwsz)); } return NULL; } HRESULT CFSFolder::_SetStgMode(DWORD grfFlags) { HRESULT hr = S_OK; if (grfFlags & STGM_TRANSACTED) hr = E_INVALIDARG; if (SUCCEEDED(hr)) _grfFlags = grfFlags; return hr; } HRESULT CFSFolder::InitializeEx(IBindCtx *pbc, LPCITEMIDLIST pidlRoot, const PERSIST_FOLDER_TARGET_INFO *pfti) { HRESULT hr = Initialize(pidlRoot); if (SUCCEEDED(hr)) { if (pfti) { _dwAttributes = pfti->dwAttributes; if (pfti->pidlTargetFolder || pfti->szTargetParsingName[0] || (pfti->csidl != -1)) { if ((pfti->csidl != -1) && (pfti->csidl & CSIDL_FLAG_PFTI_TRACKTARGET)) { // For tracking target, all other fields must be null. if (!pfti->pidlTargetFolder && !pfti->szTargetParsingName[0] && !pfti->szNetworkProvider[0]) { _csidlTrack = pfti->csidl & (~CSIDL_FLAG_MASK | CSIDL_FLAG_CREATE); } else { hr = E_INVALIDARG; } } else { _pidlTarget = ILClone(pfti->pidlTargetFolder); // on NULL returns NULL _pszPath = StrDupUnicode(pfti->szTargetParsingName); _pszNetProvider = StrDupUnicode(pfti->szNetworkProvider); if (pfti->csidl != -1) _csidl = pfti->csidl & (~CSIDL_FLAG_MASK | CSIDL_FLAG_CREATE); } } } if (SUCCEEDED(hr)) { hr = _SetStgMode(BindCtx_GetMode(pbc, STGM_READ | STGM_SHARE_DENY_WRITE)); } if (SUCCEEDED(hr) && pbc) { _fDontForceCreate = BindCtx_ContainsObject(pbc, STR_DONT_FORCE_CREATE); } } return hr; } HRESULT CFSFolder::GetFolderTargetInfo(PERSIST_FOLDER_TARGET_INFO *pfti) { HRESULT hr = S_OK; ZeroMemory(pfti, sizeof(*pfti)); _GetPathForItem(NULL, pfti->szTargetParsingName); if (_pidlTarget) hr = SHILClone(_pidlTarget, &pfti->pidlTargetFolder); if (_pszNetProvider) SHTCharToUnicode(_pszNetProvider, pfti->szNetworkProvider, ARRAYSIZE(pfti->szNetworkProvider)); pfti->dwAttributes = _dwAttributes; if (_csidlTrack >= 0) pfti->csidl = _csidlTrack | CSIDL_FLAG_PFTI_TRACKTARGET; else pfti->csidl = _GetCSIDL(); return hr; } STDAPI CFSFolder_CreateFolder(IUnknown *punkOuter, LPBC pbc, LPCITEMIDLIST pidl, const PERSIST_FOLDER_TARGET_INFO *pfti, REFIID riid, void **ppv) { *ppv = NULL; HRESULT hr; CFSFolder *pfolder = new CFSFolder(punkOuter); if (pfolder) { hr = pfolder->InitializeEx(pbc, pidl, pfti); if (SUCCEEDED(hr)) hr = pfolder->_GetInner()->QueryInterface(riid, ppv); pfolder->_GetInner()->Release(); } else hr = E_OUTOFMEMORY; return hr; } // COM object creation entry point for CLSID_ShellFSFolder STDAPI CFSFolder_CreateInstance(IUnknown *punkOuter, REFIID riid, void **ppv) { return CFSFolder_CreateFolder(punkOuter, NULL, &c_idlDesktop, NULL, riid, ppv); } BOOL CFSFolder::_IsSlowPath() { if (_bSlowPath == INVALID_PATHSPEED) { TCHAR szPath[MAX_PATH]; _GetPath(szPath); _bSlowPath = PathIsSlow(szPath, _Attributes()) ? TRUE : FALSE; } return _bSlowPath; } HRESULT CFSFolder::_GetToolTipForItem(LPCIDFOLDER pidf, REFIID riid, void **ppv) { IQueryAssociations *pqa; HRESULT hr = _AssocCreate(pidf, IID_PPV_ARG(IQueryAssociations, &pqa)); if (SUCCEEDED(hr)) { WCHAR szText[INFOTIPSIZE]; // If we are looking at a folder over a slow connection, // show only quickly accessible properties ASSOCSTR assocstr = _IsSlowPath() ? ASSOCSTR_QUICKTIP : ASSOCSTR_INFOTIP; hr = pqa->GetString(0, assocstr, NULL, szText, (DWORD *)MAKEINTRESOURCE(SIZECHARS(szText))); if (SUCCEEDED(hr)) { hr = CreateInfoTipFromItem(SAFECAST(this, IShellFolder2 *), (LPCITEMIDLIST)pidf, szText, riid, ppv); if (SUCCEEDED(hr) && _IsFileFolder(pidf)) { IUnknown *punk = (IUnknown *)*ppv; *ppv = NULL; WCHAR szPath[MAX_PATH]; hr = _GetPathForItem(pidf, szPath); if (SUCCEEDED(hr)) hr = CFolderInfoTip_CreateInstance(punk, szPath, riid, ppv); punk->Release(); } } pqa->Release(); } return hr; } // // Call the shell file operation code to delete recursively the given directory, // don't show any UI. // HRESULT CFSFolder::_Delete(LPCWSTR pszFile) { SHFILEOPSTRUCT fos = { 0 }; TCHAR szFile[MAX_PATH + 1]; SHUnicodeToTChar(pszFile, szFile, MAX_PATH); // szFile is a double-zero terminated list of files. // we can't just zero-init the szFile string to start with, // since in debug SHUnicodeToTChar will bonk the uncopied part // of the string with noise. szFile[lstrlen(szFile) + 1] = 0; fos.wFunc = FO_DELETE; fos.pFrom = szFile; fos.fFlags = FOF_NOCONFIRMATION | FOF_SILENT; return SHFileOperation(&fos) ? E_FAIL : S_OK; } // // Do a path combine thunking accordingly // HRESULT CFSFolder::_GetFullPath(LPCWSTR pszRelPath, LPWSTR pszFull) { WCHAR szPath[MAX_PATH]; _GetPathForItem(NULL, szPath); PathCombineW(pszFull, szPath, pszRelPath); return S_OK; // for now } HRESULT _FileExists(LPCWSTR pszPath, DWORD *pdwAttribs) { return PathFileExistsAndAttributesW(pszPath, pdwAttribs) ? S_OK : STG_E_FILENOTFOUND; } // IStorage STDMETHODIMP CFSFolder::CreateStream(LPCWSTR pwcsName, DWORD grfMode, DWORD res1, DWORD res2, IStream **ppstm) { HRESULT hr = _OpenCreateStream(pwcsName, grfMode, ppstm, TRUE); if (SUCCEEDED(hr)) { WCHAR szFullPath[MAX_PATH]; _GetFullPath(pwcsName, szFullPath); SHChangeNotify(SHCNE_CREATE, SHCNF_PATH, szFullPath, NULL); } return hr; } STDMETHODIMP CFSFolder::OpenStream(LPCWSTR pwcsName, void *res1, DWORD grfMode, DWORD res2, IStream **ppstm) { return _OpenCreateStream(pwcsName, grfMode, ppstm, FALSE); } HRESULT CFSFolder::_OpenCreateStream(LPCWSTR pwcsName, DWORD grfMode, IStream **ppstm, BOOL fCreate) { *ppstm = NULL; if (!pwcsName) return STG_E_INVALIDPARAMETER; WCHAR szFullPath[MAX_PATH]; _GetFullPath(pwcsName, szFullPath); HRESULT hr = SHCreateStreamOnFileEx(szFullPath, grfMode, FILE_ATTRIBUTE_NORMAL, fCreate, NULL, ppstm); return MapWin32ErrorToSTG(hr); } STDMETHODIMP CFSFolder::CreateStorage(LPCWSTR pwcsName, DWORD grfMode, DWORD res1, DWORD res2, IStorage **ppstg) { return _OpenCreateStorage(pwcsName, grfMode, ppstg, TRUE); } STDMETHODIMP CFSFolder::OpenStorage(LPCWSTR pwcsName, IStorage *pstgPriority, DWORD grfMode, SNB snbExclude, DWORD res, IStorage **ppstg) { return _OpenCreateStorage(pwcsName, grfMode, ppstg, FALSE); } HRESULT CFSFolder::_OpenCreateStorage(LPCWSTR pwcsName, DWORD grfMode, IStorage **ppstg, BOOL fCreate) { *ppstg = NULL; if (!pwcsName) return STG_E_INVALIDPARAMETER; if (grfMode & ~(STGM_READ | STGM_WRITE | STGM_READWRITE | STGM_SHARE_DENY_NONE | STGM_SHARE_DENY_READ | STGM_SHARE_DENY_WRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE )) { return STG_E_INVALIDPARAMETER; } // if the storage doesn't exist then lets create it, then drop into the // open storage to do the right thing. WCHAR szFullPath[MAX_PATH]; _GetFullPath(pwcsName, szFullPath); DWORD dwAttributes; HRESULT hr = _FileExists(szFullPath, &dwAttributes); if (SUCCEEDED(hr)) { if (dwAttributes & FILE_ATTRIBUTE_DIRECTORY) { if (fCreate) { // an object exists, we must fail grfMode == STGM_FAILIFTHERE, or // the object that exists is not a directory. // // if the STGM_CREATE flag is set and the object exists we will // delete the existing storage. // Check to make sure only one existence flag is specified // FAILIFTHERE is zero so it can't be checked if (STGM_FAILIFTHERE == (grfMode & (STGM_CREATE | STGM_CONVERT))) hr = STG_E_FILEALREADYEXISTS; else if (grfMode & STGM_CREATE) { // If they have not passed STGM_FAILIFTHERE, we'll replace an existing // folder even if its readonly or system. Its up to the caller to make // such filesystem-dependant checks first if they want to prevent that, // as there's no way to pass information about whether we should or not // down into CreateStorage if (dwAttributes & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)) SetFileAttributes(szFullPath, dwAttributes & ~(FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)); hr = _Delete(szFullPath); // // I don't trust the result from SHFileOperation, so I consider success // to be iff the directory is -gone- // if (FAILED(_FileExists(szFullPath, &dwAttributes))) { DWORD err = SHCreateDirectoryExW(NULL, szFullPath, NULL); hr = HRESULT_FROM_WIN32(err); } else { // We couldn't remove the existing directory, so return an error, // using what _Delete() said or, it if didn't return an error, E_FAIL return (FAILED(hr) ? hr : E_FAIL); } } else hr = STG_E_INVALIDPARAMETER; } } else hr = E_FAIL; // a file, not a folder! } else { // the object doesn't exist, and they have not set the STGM_CREATE, nor // is this a ::CreateStorage call. hr = STG_E_FILENOTFOUND; if (fCreate) { DWORD err = SHCreateDirectoryExW(NULL, szFullPath, NULL); hr = HRESULT_FROM_WIN32(err); } } // create a directory (we assume this will always succeed) if (SUCCEEDED(hr)) { LPITEMIDLIST pidl; hr = ParseDisplayName(NULL, NULL, (LPWSTR)pwcsName, NULL, &pidl, NULL); // const -> non const if (SUCCEEDED(hr)) { hr = BindToObject(pidl, NULL, IID_PPV_ARG(IStorage, ppstg)); ILFree(pidl); } } return hr; } STDMETHODIMP CFSFolder::CopyTo(DWORD ciidExclude, const IID *rgiidExclude, SNB snbExclude, IStorage *pstgDest) { return E_NOTIMPL; } // CFSFolder::MoveElementTo // // Copies or moves a source file (stream) to a destination storage. The stream // itself, in this case our filestream object, does the actual work of moving // the data around. STDMETHODIMP CFSFolder::MoveElementTo(LPCWSTR pwcsName, IStorage *pstgDest, LPCWSTR pwcsNewName, DWORD grfFlags) { return StgMoveElementTo(SAFECAST(this, IShellFolder *), SAFECAST(this, IStorage *), pwcsName, pstgDest, pwcsNewName, grfFlags); } STDMETHODIMP CFSFolder::Commit(DWORD grfCommitFlags) { return S_OK; // changes are commited as we go, so return S_OK; } STDMETHODIMP CFSFolder::Revert() { return E_NOTIMPL; // changes are commited as we go, so cannot implement this. } STDMETHODIMP CFSFolder::EnumElements(DWORD res1, void *res2, DWORD res3, IEnumSTATSTG **ppenum) { HRESULT hr; CFSFolderEnumSTATSTG *penum = new CFSFolderEnumSTATSTG(this); if (penum) { *ppenum = (IEnumSTATSTG *) penum; hr = S_OK; } else { *ppenum = NULL; hr = E_OUTOFMEMORY; } return hr; } STDMETHODIMP CFSFolder::DestroyElement(LPCWSTR pwcsName) { if (!pwcsName) return STG_E_INVALIDPARAMETER; WCHAR szFullPath[MAX_PATH]; _GetFullPath(pwcsName, szFullPath); return _Delete(szFullPath); } STDMETHODIMP CFSFolder::RenameElement(LPCWSTR pwcsOldName, LPCWSTR pwcsNewName) { if (!pwcsOldName || !pwcsNewName) return STG_E_INVALIDPARAMETER; WCHAR szOldPath[MAX_PATH]; _GetFullPath(pwcsOldName, szOldPath); HRESULT hr = _FileExists(szOldPath, NULL); if (SUCCEEDED(hr)) { WCHAR szNewPath[MAX_PATH]; _GetFullPath(pwcsNewName, szNewPath); hr = _FileExists(szNewPath, NULL); if (FAILED(hr)) { if (MoveFileW(szOldPath, szNewPath)) hr = S_OK; else hr = E_FAIL; } else hr = STG_E_FILEALREADYEXISTS; } return hr; } STDMETHODIMP CFSFolder::SetElementTimes(LPCWSTR pwcsName, const FILETIME *pctime, const FILETIME *patime, const FILETIME *pmtime) { if (!pwcsName) return STG_E_INVALIDPARAMETER; WCHAR szFullPath[MAX_PATH]; _GetFullPath(pwcsName, szFullPath); HRESULT hr = S_OK; HANDLE hFile = CreateFileW(szFullPath, GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); if (INVALID_HANDLE_VALUE != hFile) { if (!SetFileTime(hFile, pctime, patime, pmtime)) hr = HRESULT_FROM_WIN32(GetLastError()); CloseHandle(hFile); } else { hr = STG_E_FILENOTFOUND; } return hr; } STDMETHODIMP CFSFolder::SetClass(REFCLSID clsid) { return E_NOTIMPL; } STDMETHODIMP CFSFolder::SetStateBits(DWORD grfStateBits, DWORD grfMask) { return E_NOTIMPL; } STDMETHODIMP CFSFolder::Stat(STATSTG *pstatstg, DWORD grfStatFlag) { HRESULT hr = E_FAIL; ZeroMemory(pstatstg, sizeof(STATSTG)); // per COM conventions TCHAR szPath[MAX_PATH]; _GetPath(szPath); HANDLE hFile = CreateFile(szPath, FILE_READ_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_BACKUP_SEMANTICS, NULL); if (hFile != INVALID_HANDLE_VALUE) { BY_HANDLE_FILE_INFORMATION bhfi; if (GetFileInformationByHandle(hFile, &bhfi)) { ASSERT(bhfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY); pstatstg->type = STGTY_STORAGE; pstatstg->mtime = bhfi.ftLastWriteTime; pstatstg->ctime = bhfi.ftCreationTime; pstatstg->atime = bhfi.ftLastAccessTime; pstatstg->cbSize.HighPart = bhfi.nFileSizeHigh; pstatstg->cbSize.LowPart = bhfi.nFileSizeLow; pstatstg->grfMode = _grfFlags; pstatstg->reserved = bhfi.dwFileAttributes; hr = S_OK; if (!(grfStatFlag & STATFLAG_NONAME)) { hr = SHStrDup(PathFindFileName(szPath), &pstatstg->pwcsName); } } CloseHandle(hFile); } else hr = HRESULT_FROM_WIN32(GetLastError()); return hr; } // ITransferDest STDMETHODIMP CFSFolder::Advise(ITransferAdviseSink *pAdvise, DWORD *pdwCookie) { if (_pAdvise) return E_FAIL; _pAdvise = pAdvise; _pAdvise->AddRef(); if (pdwCookie) *pdwCookie = 1; return S_OK; } STDMETHODIMP CFSFolder::Unadvise(DWORD dwCookie) { if (1 != dwCookie) return E_INVALIDARG; if (_pAdvise) { ATOMICRELEASE(_pAdvise); return S_OK; } return S_FALSE; } HRESULT CFSFolder::_GetStatStgFromItemName(LPCTSTR szName, STATSTG * pstat) { WIN32_FIND_DATA fd; HRESULT hr = STG_E_FILENOTFOUND; HANDLE hFile = FindFirstFile(szName, &fd); if (hFile != INVALID_HANDLE_VALUE) { hr = StatStgFromFindData(&fd, STATFLAG_DEFAULT, pstat); FindClose(hFile); } return hr; } STDMETHODIMP CFSFolder::OpenElement(const WCHAR *pwcsName, STGXMODE grfMode, DWORD *pdwType, REFIID riid, void **ppunk) { return E_NOTIMPL; } STDMETHODIMP CFSFolder::CreateElement(const WCHAR *pwcsName, IShellItem *psiTemplate, STGXMODE grfMode, DWORD dwType, REFIID riid, void **ppunk) { return E_NOTIMPL; } STDMETHODIMP CFSFolder::MoveElement(IShellItem *psiItem, WCHAR *pwcsNewName, STGXMOVE grfOptions) { return E_NOTIMPL; } STDMETHODIMP CFSFolder::DestroyElement(const WCHAR * pwcsName, STGXDESTROY grfOptions) { return E_NOTIMPL; } // Create a storage object for the specified path, returning a suitable // IStorage (or error). // // In: // pwszPath -> directory // grfMode -> flags passed to IStorage::CreateStorage // ppstg -> receieves the storage object // // Out: // HRESULT STDAPI SHCreateStorageOnDirectory(LPCWSTR pszPath, DWORD grfMode, IStorage **ppstg) { *ppstg = NULL; TCHAR szPath[MAX_PATH]; SHUnicodeToTChar(pszPath, szPath, ARRAYSIZE(szPath)); LPITEMIDLIST pidl; HRESULT hr = SHILCreateFromPath(szPath, &pidl, NULL); if (SUCCEEDED(hr)) { hr = SHBindToObject(NULL, IID_X_PPV_ARG(IStorage, pidl, ppstg)); ILFree(pidl); } return hr; } STDAPI SHCreatePropStgOnFolder(LPCTSTR pszFolder, DWORD grfMode, IPropertySetStorage **ppss); HRESULT CFSFolder::_LoadPropHandler() { HRESULT hr = S_OK; if (_pstg) { hr = S_OK; } else { TCHAR szPath[MAX_PATH]; _GetPath(szPath); hr = StgOpenStorageOnFolder(szPath, _grfFlags, IID_PPV_ARG(IPropertySetStorage, &_pstg)); // if (FAILED(hr)) // hr = SHCreatePropStgOnFolder(szPath, _grfFlags, &_pstg); } return hr; } STDMETHODIMP CFSFolder::Create(REFFMTID fmtid, const CLSID *pclsid, DWORD grfFlags, DWORD grfMode, IPropertyStorage **pppropstg) { HRESULT hr = _LoadPropHandler(); if (SUCCEEDED(hr)) hr = _pstg->Create(fmtid, pclsid, grfFlags, grfMode, pppropstg); return hr; } STDMETHODIMP CFSFolder::Open(REFFMTID fmtid, DWORD grfMode, IPropertyStorage **pppropstg) { HRESULT hr = _LoadPropHandler(); if (SUCCEEDED(hr)) hr = _pstg->Open(fmtid, grfMode, pppropstg); return hr; } STDMETHODIMP CFSFolder::Delete(REFFMTID fmtid) { HRESULT hr = _LoadPropHandler(); if (SUCCEEDED(hr)) hr = _pstg->Delete(fmtid); return hr; } STDMETHODIMP CFSFolder::Enum(IEnumSTATPROPSETSTG ** ppenum) { HRESULT hr = _LoadPropHandler(); if (SUCCEEDED(hr)) hr = _pstg->Enum(ppenum); return hr; } // IItemNameLimits methods #define INVALID_NAME_CHARS L"\\/:*?\"<>|" STDMETHODIMP CFSFolder::GetValidCharacters(LPWSTR *ppwszValidChars, LPWSTR *ppwszInvalidChars) { *ppwszValidChars = NULL; return SHStrDup(INVALID_NAME_CHARS, ppwszInvalidChars); } STDMETHODIMP CFSFolder::GetMaxLength(LPCWSTR pszName, int *piMaxNameLen) { TCHAR szPath[MAX_PATH]; BOOL fShowExtension = _DefaultShowExt(); LPITEMIDLIST pidl; StrCpyN(szPath, pszName, ARRAYSIZE(szPath)); HRESULT hr = ParseDisplayName(NULL, NULL, szPath, NULL, &pidl, NULL); if (SUCCEEDED(hr)) { LPCIDFOLDER pidf = _IsValidID(pidl); if (pidf) { fShowExtension = _ShowExtension(pidf); } ILFree(pidl); } hr = _GetPath(szPath); if (SUCCEEDED(hr)) { if (PathAppend(szPath, pszName)) hr = GetCCHMaxFromPath(szPath, (UINT *)piMaxNameLen, fShowExtension); else hr = E_FAIL; } return hr; } // ISetFolderEnumRestriction methods STDMETHODIMP CFSFolder::SetEnumRestriction(DWORD dwRequired, DWORD dwForbidden) { _dwEnumRequired = dwRequired; _dwEnumForbidden = dwForbidden; return S_OK; } // IOleCommandTarget stuff STDMETHODIMP CFSFolder::QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD rgCmds[], OLECMDTEXT *pcmdtext) { HRESULT hr = OLECMDERR_E_UNKNOWNGROUP; if (pguidCmdGroup == NULL) { for (UINT i = 0; i < cCmds; i++) { // ONLY say that we support the stuff we support in ::OnExec switch (rgCmds[i].cmdID) { case OLECMDID_REFRESH: rgCmds[i].cmdf = OLECMDF_ENABLED; break; default: rgCmds[i].cmdf = 0; break; } hr = S_OK; } } return hr; } STDMETHODIMP CFSFolder::Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANTARG *pvarargIn, VARIANTARG *pvarargOut) { HRESULT hr = OLECMDERR_E_UNKNOWNGROUP; if (pguidCmdGroup == NULL) { switch (nCmdID) { case OLECMDID_REFRESH: _dwAttributes = -1; _bUpdateExtendedCols = TRUE; _tbDefShowExt = TRIBIT_UNDEFINED; _tbOfflineCSC = TRIBIT_UNDEFINED; hr = S_OK; break; } } return hr; } // global hook in the SHChangeNotify() dispatcher. note we get all change notifies // here so be careful! STDAPI CFSFolder_IconEvent(LONG lEvent, LPCITEMIDLIST pidl, LPCITEMIDLIST pidlExtra) { switch (lEvent) { case SHCNE_ASSOCCHANGED: { FlushFileClass(); // flush them all HWND hwnd = GetDesktopWindow(); if (IsWindow(hwnd)) PostMessage(hwnd, DTM_SETUPAPPRAN, 0, 0); } break; } return S_OK; } // // 317617 - Hacky update for the icon cache - ZekeL - 19-APR-2001 // this is for defview to invalidate icon indeces that are indirected // specifically if you have a LNK file and its target changes icons // (like a CD will), then the LNK is updated by defview processing the // SHCNE_UPDATEIMAGE and noticing that one of its items also matches // this image index. // // the righteous fix is to make SCN call into the fileicon cache // and reverse lookup any entries that match the icon index and invalidate // them. that way we wouldnt miss anything. // STDAPI_(void) CFSFolder_UpdateIcon(IShellFolder *psf, LPCITEMIDLIST pidl) { LPCIDFOLDER pidf = CFSFolder::_IsValidID(pidl); if (pidf) { TCHAR szName[MAX_PATH]; if (SUCCEEDED(DisplayNameOf(psf, pidl, SHGDN_FORPARSING, szName, ARRAYSIZE(szName)))) { RemoveFromIconTable(szName); } } } // ugly wrappers for external clients, remove these as possible STDAPI CFSFolder_CompareNames(LPCIDFOLDER pidf1, LPCIDFOLDER pidf2) { CFileSysItemString fsi1(pidf1), fsi2(pidf2); return ResultFromShort((short)lstrcmpi(fsi1.FSName(), fsi2.FSName())); } STDAPI_(DWORD) CFSFolder_PropertiesThread(void *pv) { return CFSFolder::_PropertiesThread(pv); } STDAPI_(LPCIDFOLDER) CFSFolder_IsValidID(LPCITEMIDLIST pidl) { return CFSFolder::_IsValidID(pidl); } STDAPI_(BOOL) CFSFolder_IsCommonItem(LPCITEMIDLIST pidl) { return CFSFolder::_IsCommonItem(pidl); } CFSIconManager::CFSIconManager() { _wszPath[0] = NULL; _cRef = 1; } HRESULT CFSIconManager::_Init(LPCITEMIDLIST pidl, IShellFolder *psf) { HRESULT hr = S_OK; if ((psf == NULL) || (pidl == NULL)) hr = E_INVALIDARG; if (SUCCEEDED(hr)) hr = DisplayNameOf(psf, pidl, SHGDN_FORPARSING, _wszPath, ARRAYSIZE(_wszPath)); return hr; } HRESULT CFSIconManager::QueryInterface(REFIID riid, void **ppv) { static const QITAB qit[] = { QITABENT(CFSIconManager, ICustomIconManager), { 0 }, }; return QISearch(this, qit, riid, ppv); } ULONG CFSIconManager::AddRef() { return InterlockedIncrement(&_cRef); } ULONG CFSIconManager::Release() { if (InterlockedDecrement(&_cRef)) return _cRef; delete this; return 0; } STDMETHODIMP CFSIconManager::GetDefaultIconHandle(HICON *phIcon) { HRESULT hr = S_OK; if (phIcon == NULL) hr = E_INVALIDARG; if (SUCCEEDED(hr)) { WCHAR szCustomizedIconPath[MAX_PATH]; int nCustomizedIconIndex; *phIcon = NULL; if (SUCCEEDED(hr = GetIcon(szCustomizedIconPath, ARRAYSIZE(szCustomizedIconPath), &nCustomizedIconIndex))) { _SetDefaultIconEx(FALSE); } SHFILEINFOW sfiw; if (SHGetFileInfoW(_wszPath, 0, &sfiw, sizeof(sfiw), SHGFI_ICON | SHGFI_LARGEICON)) { *phIcon = sfiw.hIcon; hr = S_OK; } else hr = E_FAIL; if (szCustomizedIconPath[0] != NULL) _SetIconEx(szCustomizedIconPath, nCustomizedIconIndex, FALSE); } return hr; } STDMETHODIMP CFSIconManager::SetIcon(LPCWSTR pwszIconPath, int iIcon) { return _SetIconEx(pwszIconPath, iIcon, TRUE); } STDMETHODIMP CFSIconManager::SetDefaultIcon() { return _SetDefaultIconEx(TRUE); } HRESULT CFileFolderIconManager_Create(IShellFolder *psf, LPCITEMIDLIST pidl, REFIID riid, void **ppv) { HRESULT hr = E_FAIL; *ppv = NULL; CFileFolderIconManager *pffim = new CFileFolderIconManager; if (pffim) { hr = pffim->_Init(pidl, psf); if (SUCCEEDED(hr)) hr = pffim->QueryInterface(riid, ppv); pffim->Release(); } else { hr = E_OUTOFMEMORY; } return hr; } STDMETHODIMP CFileFolderIconManager::_SetIconEx(LPCWSTR pwszIconPath, int iIcon, BOOL fChangeNotify) { HRESULT hr = S_OK; WCHAR wszExpandedIconPath[MAX_PATH]; if (SHExpandEnvironmentStrings(pwszIconPath, wszExpandedIconPath, ARRAYSIZE(wszExpandedIconPath)) == 0) hr = E_FAIL; if (SUCCEEDED(hr)) { SHFOLDERCUSTOMSETTINGS fcs; ZeroMemory(&fcs, sizeof(fcs)); fcs.dwSize = sizeof(fcs); fcs.dwMask = FCSM_ICONFILE; fcs.pszIconFile = (LPWSTR) wszExpandedIconPath; fcs.cchIconFile = ARRAYSIZE(wszExpandedIconPath); fcs.iIconIndex = iIcon; hr = SHGetSetFolderCustomSettings(&fcs, _wszPath, FCS_FORCEWRITE); if (SUCCEEDED(hr) && fChangeNotify) { /* // Work Around - We need to pump a image change message for the folder icon change. // The right way is the following. But for some reason, the shell views which // display the folder, don't update there images. So as a work around, we pump a // SHCNE_RENAMEFOLDER message. This works!. SHFILEINFO sfi; if (SHGetFileInfo(pfpsp->szPath, 0, &sfi, sizeof(sfi), SHGFI_ICONLOCATION)) { int iIconIndex = Shell_GetCachedImageIndex(sfi.szDisplayName, sfi.iIcon, 0); SHUpdateImage(PathFindFileName(sfi.szDisplayName), sfi.iIcon, 0, iIconIndex); } */ SHChangeNotify(SHCNE_RENAMEFOLDER, SHCNF_PATH, _wszPath, _wszPath); } } return hr; } STDMETHODIMP CFileFolderIconManager::_SetDefaultIconEx(BOOL fChangeNotify) { HRESULT hr = E_FAIL; SHFOLDERCUSTOMSETTINGS fcs; ZeroMemory(&fcs, sizeof(fcs)); fcs.dwSize = sizeof(fcs); fcs.dwMask = FCSM_ICONFILE; fcs.pszIconFile = NULL; fcs.cchIconFile = 0; fcs.iIconIndex = 0; hr = SHGetSetFolderCustomSettings(&fcs, _wszPath, FCS_FORCEWRITE); if (SUCCEEDED(hr) && fChangeNotify) { /* // Work Around - We need to pump a image change message for the folder icon change. // The right way is the following. But for some reason, the shell views which // display the folder, don't update there images. So as a work around, we pump a // SHCNE_RENAMEFOLDER message. This works!. SHFILEINFO sfi; if (SHGetFileInfo(pfpsp->szPath, 0, &sfi, sizeof(sfi), SHGFI_ICONLOCATION)) { int iIconIndex = Shell_GetCachedImageIndex(sfi.szDisplayName, sfi.iIcon, 0); SHUpdateImage(PathFindFileName(sfi.szDisplayName), sfi.iIcon, 0, iIconIndex); } */ SHChangeNotify(SHCNE_RENAMEFOLDER, SHCNF_PATH, _wszPath, _wszPath); } return hr; } HRESULT CFileFolderIconManager::GetIcon(LPWSTR pszIconPath, int cchszIconPath, int *piIconIndex) { HRESULT hr = S_OK; if ((pszIconPath == NULL) || (cchszIconPath < MAX_PATH) || (piIconIndex == NULL)) hr = E_INVALIDARG; if (SUCCEEDED(hr)) { SHFOLDERCUSTOMSETTINGS fcs; ZeroMemory(&fcs, sizeof(fcs)); fcs.dwSize = sizeof(fcs); fcs.dwMask = FCSM_ICONFILE; fcs.pszIconFile = pszIconPath; fcs.cchIconFile = cchszIconPath; hr = SHGetSetFolderCustomSettings(&fcs, _wszPath, FCS_READ); if (SUCCEEDED(hr)) { *piIconIndex = fcs.iIconIndex; } } return hr; }