/**************************************************************************
* CreateFolderEnumList()
*/
BOOL CreateFolderEnumList(IEnumIDListImpl *list, LPCWSTR lpszPath, DWORD dwFlags)
{
LPITEMIDLIST pidl=NULL;
WIN32_FIND_DATAW stffile;
HANDLE hFile;
WCHAR szPath[MAX_PATH];
BOOL succeeded = TRUE;
static const WCHAR stars[] = { '*','.','*',0 };
static const WCHAR dot[] = { '.',0 };
static const WCHAR dotdot[] = { '.','.',0 };
TRACE("(%p)->(path=%s flags=0x%08x)\n", list, debugstr_w(lpszPath), dwFlags);
if(!lpszPath || !lpszPath[0]) return FALSE;
strcpyW(szPath, lpszPath);
PathAddBackslashW(szPath);
strcatW(szPath,stars);
hFile = FindFirstFileW(szPath,&stffile);
if ( hFile != INVALID_HANDLE_VALUE )
{
BOOL findFinished = FALSE;
do
{
if ( !(stffile.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN)
|| (dwFlags & SHCONTF_INCLUDEHIDDEN) )
{
if ( (stffile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
dwFlags & SHCONTF_FOLDERS &&
strcmpW(stffile.cFileName, dot) && strcmpW(stffile.cFileName, dotdot))
{
pidl = _ILCreateFromFindDataW(&stffile);
succeeded = succeeded && AddToEnumList(list, pidl);
}
else if (!(stffile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
&& dwFlags & SHCONTF_NONFOLDERS)
{
pidl = _ILCreateFromFindDataW(&stffile);
succeeded = succeeded && AddToEnumList(list, pidl);
}
}
if (succeeded)
{
if (!FindNextFileW(hFile, &stffile))
{
if (GetLastError() == ERROR_NO_MORE_FILES)
findFinished = TRUE;
else
succeeded = FALSE;
}
}
} while (succeeded && !findFinished);
FindClose(hFile);
}
return succeeded;
}
static BOOL CreateMyCompEnumList(IEnumIDListImpl *list, DWORD dwFlags)
{
BOOL ret = TRUE;
TRACE("(%p)->(flags=0x%08x)\n", list, dwFlags);
/* enumerate the folders */
if (dwFlags & SHCONTF_FOLDERS)
{
WCHAR wszDriveName[] = {'A', ':', '\\', '\0'};
DWORD dwDrivemap = get_drive_map();
HKEY hkey;
UINT i;
while (ret && wszDriveName[0]<='Z')
{
if(dwDrivemap & 0x00000001L)
ret = AddToEnumList(list, _ILCreateDrive(wszDriveName));
wszDriveName[0]++;
dwDrivemap = dwDrivemap >> 1;
}
TRACE("-- (%p)-> enumerate (mycomputer shell extensions)\n",list);
for (i=0; i<2; i++) {
if (ret && !RegOpenKeyExW(i == 0 ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER,
MyComputer_NameSpaceW, 0, KEY_READ, &hkey))
{
WCHAR iid[50];
int i=0;
while (ret)
{
DWORD size;
LONG r;
size = sizeof(iid) / sizeof(iid[0]);
r = RegEnumKeyExW(hkey, i, iid, &size, 0, NULL, NULL, NULL);
if (ERROR_SUCCESS == r)
{
/* FIXME: shell extensions, shouldn't the type be
* PT_SHELLEXT? */
ret = AddToEnumList(list, _ILCreateGuidFromStrW(iid));
i++;
}
else if (ERROR_NO_MORE_ITEMS == r)
break;
else
ret = FALSE;
}
RegCloseKey(hkey);
}
}
}
static BOOL CreateDesktopEnumList(IEnumIDListImpl *list, DWORD dwFlags)
{
BOOL ret = TRUE;
WCHAR szPath[MAX_PATH];
TRACE("(%p)->(flags=0x%08x)\n", list, dwFlags);
/* enumerate the root folders */
if (dwFlags & SHCONTF_FOLDERS)
{
HKEY hkey;
UINT i;
/* create the pidl for This item */
ret = AddToEnumList(list, _ILCreateMyComputer());
for (i=0; i<2; i++) {
if (ret && !RegOpenKeyExW(i == 0 ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER,
Desktop_NameSpaceW, 0, KEY_READ, &hkey))
{
WCHAR iid[50];
int i=0;
while (ret)
{
DWORD size;
LONG r;
size = sizeof (iid) / sizeof (iid[0]);
r = RegEnumKeyExW(hkey, i, iid, &size, 0, NULL, NULL, NULL);
if (ERROR_SUCCESS == r)
{
ret = AddToEnumList(list, _ILCreateGuidFromStrW(iid));
i++;
}
else if (ERROR_NO_MORE_ITEMS == r)
break;
else
ret = FALSE;
}
RegCloseKey(hkey);
}
}
}
/* enumerate the elements in %windir%\desktop */
SHGetSpecialFolderPathW(0, szPath, CSIDL_DESKTOPDIRECTORY, FALSE);
ret = ret && CreateFolderEnumList(list, szPath, dwFlags);
return ret;
}
/**************************************************************************
* CPrintersEnum::CreatePrintersEnumList()
*/
BOOL CPrintersEnum::CreatePrintersEnumList(DWORD dwFlags)
{
BOOL ret = TRUE;
TRACE("(%p)->(flags=0x%08lx) \n", this, dwFlags);
/* enumerate the folders */
if (dwFlags & SHCONTF_NONFOLDERS)
{
DWORD needed = 0, num = 0, i;
PRINTER_INFO_4W *pi;
EnumPrintersW(PRINTER_ENUM_LOCAL, NULL, 4, NULL, 0, &needed, &num);
if (!needed)
return ret;
pi = (PRINTER_INFO_4W *)HeapAlloc(GetProcessHeap(), 0, needed);
if(!EnumPrintersW(PRINTER_ENUM_LOCAL, NULL, 4, (LPBYTE)pi, needed, &needed, &num)) {
HeapFree(GetProcessHeap(), 0, pi);
return FALSE;
}
for(i = 0; i < num; i++) {
LPITEMIDLIST pidl = _ILCreatePrinterItem(&pi[i]);
if (pidl)
{
if (!AddToEnumList(pidl))
SHFree(pidl);
}
}
HeapFree(GetProcessHeap(), 0, pi);
}
return ret;
}
static int SHELL_RegisterCPanelFolders(IEnumIDList* list, HKEY hkey_root, LPCSTR szRepPath)
{
char name[MAX_PATH];
HKEY hkey;
int cnt = 0;
if (RegOpenKeyA(hkey_root, szRepPath, &hkey) == ERROR_SUCCESS)
{
int idx = 0;
for(;; ++idx)
{
if (RegEnumKeyA(hkey, idx, name, MAX_PATH) != ERROR_SUCCESS)
break;
if (*name == '{')
{
LPITEMIDLIST pidl = _ILCreateGuidFromStrA(name);
if (pidl && AddToEnumList(list, pidl))
++cnt;
}
}
RegCloseKey(hkey);
}
return cnt;
}
/**************************************************************************
* CDesktopFolderEnumZ::CreateFontsEnumList()
*/
BOOL CDesktopFolderEnumZ::CreateFontsEnumList(DWORD dwFlags)
{
WCHAR szPath[MAX_PATH];
WCHAR szName[LF_FACESIZE+20];
WCHAR szFile[MAX_PATH];
LPWSTR pszPath;
UINT Length;
LONG ret;
DWORD dwType, dwName, dwFile, dwIndex;
LPITEMIDLIST pidl;
HKEY hKey;
if (dwFlags & SHCONTF_NONFOLDERS)
{
if (!SHGetSpecialFolderPathW(NULL, szPath, CSIDL_FONTS, FALSE))
return FALSE;
pszPath = PathAddBackslashW(szPath);
if (!pszPath)
return FALSE;
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Fonts", 0, KEY_READ, &hKey) != ERROR_SUCCESS)
return FALSE;
Length = pszPath - szPath;
dwIndex = 0;
do
{
dwName = sizeof(szName) / sizeof(WCHAR);
dwFile = sizeof(szFile) / sizeof(WCHAR);
ret = RegEnumValueW(hKey, dwIndex++, szName, &dwName, NULL, &dwType, (LPBYTE)szFile, &dwFile);
if (ret == ERROR_SUCCESS)
{
szFile[(sizeof(szFile)/sizeof(WCHAR))-1] = L'\0';
if (dwType == REG_SZ && wcslen(szFile) + Length + 1 < (sizeof(szPath) / sizeof(WCHAR)))
{
wcscpy(&szPath[Length], szFile);
pidl = _ILCreateFontItem(szName, szPath);
TRACE("pidl %p name %s path %s\n", pidl, debugstr_w(szName), debugstr_w(szPath));
if (pidl)
{
if (!AddToEnumList(pidl))
SHFree(pidl);
}
}
}
} while(ret != ERROR_NO_MORE_ITEMS);
RegCloseKey(hKey);
}
return TRUE;
}
BOOL WINAPI CRecycleBinEnum::CBEnumRecycleBin(IN HANDLE hDeletedFile)
{
PDELETED_FILE_DETAILS_W pFileDetails;
DWORD dwSize;
LPITEMIDLIST pidl = NULL;
BOOL ret;
if (!GetDeletedFileDetailsW(hDeletedFile,
0,
NULL,
&dwSize) &&
GetLastError() != ERROR_INSUFFICIENT_BUFFER)
{
ERR("GetDeletedFileDetailsW failed\n");
return FALSE;
}
pFileDetails = (DELETED_FILE_DETAILS_W *)SHAlloc(dwSize);
if (!pFileDetails)
{
ERR("No memory\n");
return FALSE;
}
if (!GetDeletedFileDetailsW(hDeletedFile,
dwSize,
pFileDetails,
NULL))
{
ERR("GetDeletedFileDetailsW failed\n");
SHFree(pFileDetails);
return FALSE;
}
pidl = _ILCreateRecycleItem(pFileDetails);
if (!pidl)
{
SHFree(pFileDetails);
return FALSE;
}
ret = AddToEnumList(pidl);
if (!ret)
SHFree(pidl);
SHFree(pFileDetails);
TRACE("Returning %d\n", ret);
CloseRecycleBinHandle(hDeletedFile);
return ret;
}
/**************************************************************************
* ISF_ControlPanel_fnEnumObjects
*/
static BOOL SHELL_RegisterCPanelApp(IEnumIDList* list, LPCSTR path)
{
LPITEMIDLIST pidl;
CPlApplet* applet;
CPanel panel;
CPLINFO info;
unsigned i;
int iconIdx;
char displayName[MAX_PATH];
char comment[MAX_PATH];
WCHAR wpath[MAX_PATH];
MultiByteToWideChar(CP_ACP, 0, path, -1, wpath, MAX_PATH);
panel.first = NULL;
applet = Control_LoadApplet(0, wpath, &panel);
if (applet)
{
for(i=0; i<applet->count; ++i)
{
WideCharToMultiByte(CP_ACP, 0, applet->info[i].szName, -1, displayName, MAX_PATH, 0, 0);
WideCharToMultiByte(CP_ACP, 0, applet->info[i].szInfo, -1, comment, MAX_PATH, 0, 0);
applet->proc(0, CPL_INQUIRE, i, (LPARAM)&info);
if (info.idIcon > 0)
iconIdx = -info.idIcon; /* negative icon index instead of icon number */
else
iconIdx = 0;
pidl = _ILCreateCPanelApplet(path, displayName, comment, iconIdx);
if (pidl)
AddToEnumList(list, pidl);
}
Control_UnloadApplet(applet);
}
return TRUE;
}
static HRESULT WINAPI RecycleBin_EnumObjects(IShellFolder2 *iface, HWND hwnd, SHCONTF grfFlags, IEnumIDList **ppenumIDList)
{
RecycleBin *This = impl_from_IShellFolder2(iface);
IEnumIDList *list;
LPITEMIDLIST *pidls;
HRESULT ret;
int pidls_count;
int i=0;
TRACE("(%p, %p, %x, %p)\n", This, hwnd, grfFlags, ppenumIDList);
if (grfFlags & SHCONTF_NONFOLDERS)
{
*ppenumIDList = NULL;
if (FAILED(ret = TRASH_EnumItems(&pidls, &pidls_count)))
return ret;
list = IEnumIDList_Constructor();
if (list == NULL)
goto failed;
for (i=0; i<pidls_count; i++)
if (!AddToEnumList(list, pidls[i]))
goto failed;
*ppenumIDList = list;
}
else
{
*ppenumIDList = IEnumIDList_Constructor();
if (*ppenumIDList == NULL)
return E_OUTOFMEMORY;
}
return S_OK;
failed:
if (list)
IEnumIDList_Release(list);
for (; i<pidls_count; i++)
ILFree(pidls[i]);
SHFree(pidls);
return E_OUTOFMEMORY;
}
HRESULT WINAPI CDesktopFolderEnum::Initialize(CDesktopFolder *desktopFolder, HWND hwndOwner, DWORD dwFlags)
{
BOOL ret = TRUE;
WCHAR szPath[MAX_PATH];
static const WCHAR MyDocumentsClassString[] = L"{450D8FBA-AD25-11D0-98A8-0800361B1103}";
static const WCHAR Desktop_NameSpaceW[] = L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Desktop\\Namespace";
TRACE("(%p)->(flags=0x%08x)\n", this, dwFlags);
/* enumerate the root folders */
if (dwFlags & SHCONTF_FOLDERS)
{
HKEY hkey;
UINT i;
DWORD dwResult;
/* create the pidl for This item */
if (IsNamespaceExtensionHidden(MyDocumentsClassString) < 1)
{
ret = AddToEnumList(_ILCreateMyDocuments());
}
ret = AddToEnumList(_ILCreateMyComputer());
for (i = 0; i < 2; i++)
{
if (i == 0)
dwResult = RegOpenKeyExW(HKEY_LOCAL_MACHINE, Desktop_NameSpaceW, 0, KEY_READ, &hkey);
else
dwResult = RegOpenKeyExW(HKEY_CURRENT_USER, Desktop_NameSpaceW, 0, KEY_READ, &hkey);
if (dwResult == ERROR_SUCCESS)
{
WCHAR iid[50];
LPITEMIDLIST pidl;
int i = 0;
while (ret)
{
DWORD size;
LONG r;
size = sizeof (iid) / sizeof (iid[0]);
r = RegEnumKeyExW(hkey, i, iid, &size, 0, NULL, NULL, NULL);
if (ERROR_SUCCESS == r)
{
if (IsNamespaceExtensionHidden(iid) < 1)
{
pidl = _ILCreateGuidFromStrW(iid);
if (pidl != NULL)
{
if (!HasItemWithCLSID(pidl))
{
ret = AddToEnumList(pidl);
}
else
{
SHFree(pidl);
}
}
}
}
else if (ERROR_NO_MORE_ITEMS == r)
break;
else
ret = FALSE;
i++;
}
RegCloseKey(hkey);
}
}
for (i = 0; i < 2; i++)
{
if (i == 0)
dwResult = RegOpenKeyExW(HKEY_LOCAL_MACHINE, ClassicStartMenuW, 0, KEY_READ, &hkey);
else
dwResult = RegOpenKeyExW(HKEY_CURRENT_USER, ClassicStartMenuW, 0, KEY_READ, &hkey);
if (dwResult == ERROR_SUCCESS)
{
DWORD j = 0, dwVal, Val, dwType, dwIID;
LONG r;
WCHAR iid[50];
while(ret)
{
dwVal = sizeof(Val);
dwIID = sizeof(iid) / sizeof(WCHAR);
r = RegEnumValueW(hkey, j++, iid, &dwIID, NULL, &dwType, (LPBYTE)&Val, &dwVal);
if (r == ERROR_SUCCESS)
{
if (Val == 0 && dwType == REG_DWORD)
{
LPITEMIDLIST pidl = _ILCreateGuidFromStrW(iid);
if (pidl != NULL)
{
if (!HasItemWithCLSID(pidl))
{
AddToEnumList(pidl);
}
else
{
SHFree(pidl);
}
}
}
}
else if (ERROR_NO_MORE_ITEMS == r)
break;
else
ret = FALSE;
}
RegCloseKey(hkey);
}
}
}
/* enumerate the elements in %windir%\desktop */
ret = ret && SHGetSpecialFolderPathW(0, szPath, CSIDL_DESKTOPDIRECTORY, FALSE);
ret = ret && CreateFolderEnumList(szPath, dwFlags);
ret = ret && SHGetSpecialFolderPathW(0, szPath, CSIDL_COMMON_DESKTOPDIRECTORY, FALSE);
ret = ret && CreateFolderEnumList(szPath, dwFlags);
return ret ? S_OK : E_FAIL;
}
BOOL CNetFolderEnum::EnumerateRec(LPNETRESOURCE lpNet)
{
BOOL bRet = TRUE;
DWORD dRet;
HANDLE hEnum;
LPNETRESOURCE lpRes;
DWORD dSize = 0x1000;
DWORD dCount = -1;
LPNETRESOURCE lpCur;
dRet = WNetOpenEnum(RESOURCE_GLOBALNET, RESOURCETYPE_DISK, 0, lpNet, &hEnum);
if (dRet != WN_SUCCESS)
{
ERR("WNetOpenEnum() failed: %x\n", dRet);
return FALSE;
}
lpRes = (LPNETRESOURCE)CoTaskMemAlloc(dSize);
if (!lpRes)
{
ERR("CoTaskMemAlloc() failed\n");
WNetCloseEnum(hEnum);
return FALSE;
}
do
{
dSize = 0x1000;
dCount = -1;
memset(lpRes, 0, dSize);
dRet = WNetEnumResource(hEnum, &dCount, lpRes, &dSize);
if (dRet == WN_SUCCESS || dRet == WN_MORE_DATA)
{
lpCur = lpRes;
for (; dCount; dCount--)
{
TRACE("lpRemoteName: %S\n", lpCur->lpRemoteName);
if ((lpCur->dwUsage & RESOURCEUSAGE_CONTAINER) == RESOURCEUSAGE_CONTAINER)
{
TRACE("Found provider: %S\n", lpCur->lpProvider);
EnumerateRec(lpCur);
}
else
{
LPITEMIDLIST pidl;
#ifdef HACKY_UNC_PATHS
pidl = ILCreateFromNetworkPlaceW(lpCur->lpRemoteName);
#endif
if (pidl != NULL)
bRet = AddToEnumList(pidl);
else
{
ERR("ILCreateFromPathW() failed\n");
bRet = FALSE;
break;
}
}
lpCur++;
}
}
} while (dRet != WN_NO_MORE_ENTRIES);
CoTaskMemFree(lpRes);
WNetCloseEnum(hEnum);
TRACE("Done: %u\n", bRet);
return bRet;
}
BOOL CDrivesFolderEnum::CreateMyCompEnumList(DWORD dwFlags)
{
BOOL bRet = TRUE;
static const WCHAR MyComputer_NameSpaceW[] = L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\MyComputer\\Namespace";
TRACE("(%p)->(flags=0x%08x)\n", this, dwFlags);
/* enumerate the folders */
if (dwFlags & SHCONTF_FOLDERS)
{
WCHAR wszDriveName[] = {'A', ':', '\\', '\0'};
DWORD dwDrivemap = GetLogicalDrives();
HKEY hKey;
UINT i;
while (bRet && wszDriveName[0] <= 'Z')
{
if(dwDrivemap & 0x00000001L)
bRet = AddToEnumList(_ILCreateDrive(wszDriveName));
wszDriveName[0]++;
dwDrivemap = dwDrivemap >> 1;
}
TRACE("-- (%p)-> enumerate (mycomputer shell extensions)\n", this);
for (i = 0; i < 2; i++)
{
if (bRet && ERROR_SUCCESS == RegOpenKeyExW(i == 0 ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER,
MyComputer_NameSpaceW, 0, KEY_READ, &hKey))
{
WCHAR wszBuf[50];
DWORD dwSize, j = 0;
LONG ErrorCode;
LPITEMIDLIST pidl;
while (bRet)
{
dwSize = sizeof(wszBuf) / sizeof(wszBuf[0]);
ErrorCode = RegEnumKeyExW(hKey, j, wszBuf, &dwSize, 0, NULL, NULL, NULL);
if (ERROR_SUCCESS == ErrorCode)
{
if (wszBuf[0] != L'{')
{
dwSize = sizeof(wszBuf);
RegGetValueW(hKey, wszBuf, NULL, RRF_RT_REG_SZ, NULL, wszBuf, &dwSize);
}
/* FIXME: shell extensions - the type should be PT_SHELLEXT (tested) */
pidl = _ILCreateGuidFromStrW(wszBuf);
if (pidl != NULL)
bRet = AddToEnumList(pidl);
else
ERR("Invalid MyComputer namespace extesion: %s\n", wszBuf);
j++;
}
else if (ERROR_NO_MORE_ITEMS == ErrorCode)
break;
else
bRet = FALSE;
}
RegCloseKey(hKey);
}
}
}
