ReactOS 0.4.16-dev-737-g3368adc
CFSFolder.cpp
Go to the documentation of this file.
1/*
2 * PROJECT: shell32
3 * LICENSE: LGPL-2.1-or-later (https://spdx.org/licenses/LGPL-2.1-or-later)
4 * PURPOSE: file system folder
5 * COPYRIGHT: Copyright 1997 Marcus Meissner
6 * Copyright 1998, 1999, 2002 Juergen Schmied
7 * Copyright 2019-2024 Katayama Hirofumi MZ
8 * Copyright 2020 Mark Jansen (mark.jansen@reactos.org)
9 */
10
11#include <precomp.h>
12
14
15static HRESULT SHELL32_GetCLSIDForDirectory(LPCWSTR pwszDir, LPCWSTR KeyName, CLSID* pclsidFolder);
16
18{
19 const BYTE mask = PT_FS | PT_FS_FOLDER_FLAG | PT_FS_FILE_FLAG;
20 const BYTE type = _ILGetType(pidl);
21 return (type & mask) == (PT_FS | PT_FS_FOLDER_FLAG) || (type == PT_FS && ILGetNext(pidl));
22}
23
25{
26 FileStructW* pDataW = _ILGetFileStructW(pidl);
27 if (pDataW)
28 return pDataW->wszName;
30 if (_ILGetFSType(pidl) & PT_FS_UNICODE_FLAG)
31 return (LPWSTR)pdata->u.file.szNames;
32 if (_ILSimpleGetTextW(pidl, Buf, cchMax))
33 return Buf;
34 return NULL;
35}
36
37static BOOL IsRealItem(const ITEMIDLIST &idl)
38{
39 // PIDLs created with SHSimpleIDListFromPath contain no data, otherwise, the item is "real"
40 FileStruct &fsitem = ((PIDLDATA*)idl.mkid.abID)->u.file;
41 return fsitem.dwFileSize | fsitem.uFileDate;
42}
43
45{
47 if (ItemIsFolder(pidl))
48 {
50 }
51 else
52 {
56 }
57 if (FAILED(hr) && cchMax)
58 Buf[0] = UNICODE_NULL;
59}
60
62{
63 HKEY hkey;
64
66 DWORD dwSize = sizeof(FullName);
67 wsprintf(FullName, L"%s\\%s", pExtension, KeyName);
68
70 if (!res)
71 return hkey;
72
74 if (res)
75 {
76 WARN("Failed to get progid for extension %S (%x), error %d\n", pExtension, pExtension, res);
77 return NULL;
78 }
79
80 wcscat(FullName, L"\\");
82
83 hkey = NULL;
85 if (res)
86 WARN("Could not open key %S for extension %S\n", KeyName, pExtension);
87
88 return hkey;
89}
90
92{
93 if (!_ILIsValue(pidl))
94 {
95 ERR("Invalid pidl!\n");
96 return NULL;
97 }
98
99 LPCWSTR name = GetItemFileName(pidl, Buf, cchMax);
100 LPCWSTR pExtension = name ? PathFindExtensionW(name) : NULL;
101 if (!pExtension || *pExtension == UNICODE_NULL)
102 {
103 WARN("No extension for %S!\n", name);
104 return NULL;
105 }
106 return pExtension;
107}
108
110{
111 HKEY hkeyProgId = OpenKeyFromFileType(pExtension, KeyName);
112 if (!hkeyProgId)
113 {
114 WARN("OpenKeyFromFileType failed for key %S\n", KeyName);
115 return S_FALSE;
116 }
117
118 WCHAR wszCLSIDValue[CHARS_IN_GUID];
119 DWORD dwSize = sizeof(wszCLSIDValue);
120 LONG res = RegGetValueW(hkeyProgId, NULL, NULL, RRF_RT_REG_SZ, NULL, wszCLSIDValue, &dwSize);
121 RegCloseKey(hkeyProgId);
122 if (res)
123 {
124 ERR("OpenKeyFromFileType succeeded but RegGetValueW failed\n");
125 return S_FALSE;
126 }
127
128#if 0
129 {
131 L"Software\\Microsoft\\Windows\\CurrentVersion\\Shell Extensions\\Approved",
132 wszCLSIDValue,
134 NULL,
135 NULL,
136 NULL);
137 if (res != ERROR_SUCCESS)
138 {
139 ERR("DropHandler extension %S not approved\n", wszName);
140 return E_ACCESSDENIED;
141 }
142 }
143#endif
144
146 L"Software\\Microsoft\\Windows\\CurrentVersion\\Shell Extensions\\Blocked",
147 wszCLSIDValue,
149 NULL,
150 NULL,
152 {
153 ERR("Extension %S not approved\n", wszCLSIDValue);
154 return E_ACCESSDENIED;
155 }
156
157 HRESULT hres = CLSIDFromString (wszCLSIDValue, pclsid);
159 return hres;
160
161 return S_OK;
162}
163
165{
166 WCHAR buf[256];
167 LPCWSTR pExtension = ExtensionFromPidl(pidl, buf, _countof(buf));
168 if (!pExtension)
169 return S_FALSE;
170
171 return GetCLSIDForFileTypeFromExtension(pExtension, KeyName, pclsid);
172}
173
174static HRESULT
176{
177 if (!HLM_GetIconW(IDI_SHELL_FOLDER - 1, szIconFile, cchMax, piIndex))
178 {
179 if (!HCR_GetIconW(L"Folder", szIconFile, NULL, cchMax, piIndex))
180 {
181 StringCchCopyW(szIconFile, cchMax, swShell32Name);
182 *piIndex = -IDI_SHELL_FOLDER;
183 }
184 }
185
186 if (uFlags & GIL_OPENICON)
187 {
188 // next icon
189 if (*piIndex < 0)
190 (*piIndex)--;
191 else
192 (*piIndex)++;
193 }
194
195 return S_OK;
196}
197
198static BOOL
199getShellClassInfo(LPCWSTR Entry, LPWSTR pszValue, DWORD cchValueLen, LPCWSTR IniFile)
200{
201 return GetPrivateProfileStringW(L".ShellClassInfo", Entry, NULL, pszValue, cchValueLen, IniFile);
202}
203
204static HRESULT
206 LPWSTR szIconFile, UINT cchMax, int *piIndex, UINT *pwFlags)
207{
208 DWORD dwFileAttrs;
209 WCHAR wszPath[MAX_PATH];
210 WCHAR wszIniFullPath[MAX_PATH];
211
212 if (uFlags & GIL_DEFAULTICON)
213 goto Quit;
214
215 // get path
216 if (!ILGetDisplayNameExW(psf, pidl, wszPath, 0))
217 goto Quit;
218 if (!PathIsDirectoryW(wszPath))
219 goto Quit;
220
221 // read-only or system folder?
222 dwFileAttrs = _ILGetFileAttributes(ILFindLastID(pidl), NULL, 0);
223 if ((dwFileAttrs & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)) == 0)
224 goto Quit;
225
226 // build the full path of ini file
227 StringCchCopyW(wszIniFullPath, _countof(wszIniFullPath), wszPath);
228 PathAppendW(wszIniFullPath, L"desktop.ini");
229
230 WCHAR wszValue[MAX_PATH], wszTemp[MAX_PATH];
231 if (getShellClassInfo(L"IconFile", wszValue, _countof(wszValue), wszIniFullPath))
232 {
233 // wszValue --> wszTemp
234 ExpandEnvironmentStringsW(wszValue, wszTemp, _countof(wszTemp));
235
236 // wszPath + wszTemp --> wszPath
237 if (PathIsRelativeW(wszTemp))
238 PathAppendW(wszPath, wszTemp);
239 else
240 StringCchCopyW(wszPath, _countof(wszPath), wszTemp);
241
242 // wszPath --> szIconFile
243 GetFullPathNameW(wszPath, cchMax, szIconFile, NULL);
244
245 *piIndex = GetPrivateProfileIntW(L".ShellClassInfo", L"IconIndex", 0, wszIniFullPath);
246 return S_OK;
247 }
248 else if (getShellClassInfo(L"CLSID", wszValue, _countof(wszValue), wszIniFullPath) &&
249 HCR_GetIconW(wszValue, szIconFile, NULL, cchMax, piIndex))
250 {
251 return S_OK;
252 }
253 else if (getShellClassInfo(L"CLSID2", wszValue, _countof(wszValue), wszIniFullPath) &&
254 HCR_GetIconW(wszValue, szIconFile, NULL, cchMax, piIndex))
255 {
256 return S_OK;
257 }
258 else if (getShellClassInfo(L"IconResource", wszValue, _countof(wszValue), wszIniFullPath))
259 {
260 // wszValue --> wszTemp
261 ExpandEnvironmentStringsW(wszValue, wszTemp, _countof(wszTemp));
262
263 // parse the icon location
264 *piIndex = PathParseIconLocationW(wszTemp);
265
266 // wszPath + wszTemp --> wszPath
267 if (PathIsRelativeW(wszTemp))
268 PathAppendW(wszPath, wszTemp);
269 else
270 StringCchCopyW(wszPath, _countof(wszPath), wszTemp);
271
272 // wszPath --> szIconFile
273 GetFullPathNameW(wszPath, cchMax, szIconFile, NULL);
274 return S_OK;
275 }
276
277Quit:
278 return getDefaultIconLocation(szIconFile, cchMax, piIndex, uFlags);
279}
280
282{
283 CComPtr<IDefaultExtractIconInit> initIcon;
284 HRESULT hr;
285 int icon_idx = 0;
286 UINT flags = 0; // FIXME: Use it!
287 WCHAR wTemp[MAX_PATH] = L"";
288
290 if (FAILED(hr))
291 return hr;
292
293 if (_ILIsFolder (pidl))
294 {
296 pidl, 0, wTemp, _countof(wTemp),
297 &icon_idx,
298 &flags)))
299 {
300 initIcon->SetNormalIcon(wTemp, icon_idx);
301 // FIXME: if/when getIconLocationForFolder does something for
302 // GIL_FORSHORTCUT, code below should be uncommented. and
303 // the following line removed.
304 initIcon->SetShortcutIcon(wTemp, icon_idx);
305 }
307 pidl, GIL_DEFAULTICON, wTemp, _countof(wTemp),
308 &icon_idx,
309 &flags)))
310 {
311 initIcon->SetDefaultIcon(wTemp, icon_idx);
312 }
313 // if (SUCCEEDED(getIconLocationForFolder(psf,
314 // pidl, GIL_FORSHORTCUT, wTemp, _countof(wTemp),
315 // &icon_idx,
316 // &flags)))
317 // {
318 // initIcon->SetShortcutIcon(wTemp, icon_idx);
319 // }
321 pidl, GIL_OPENICON, wTemp, _countof(wTemp),
322 &icon_idx,
323 &flags)))
324 {
325 initIcon->SetOpenIcon(wTemp, icon_idx);
326 }
327 }
328 else
329 {
330 WCHAR extbuf[256];
331 LPCWSTR pExtension = ExtensionFromPidl(pidl, extbuf, _countof(extbuf));
332 HKEY hkey = pExtension ? OpenKeyFromFileType(pExtension, L"DefaultIcon") : NULL;
333 if (!hkey)
334 WARN("Could not open DefaultIcon key!\n");
335
336 DWORD dwSize = sizeof(wTemp);
337 if (hkey && !SHQueryValueExW(hkey, NULL, NULL, NULL, wTemp, &dwSize))
338 {
339 WCHAR sNum[5];
340 if (ParseFieldW (wTemp, 2, sNum, 5))
341 icon_idx = _wtoi(sNum);
342 else
343 icon_idx = 0; /* sometimes the icon number is missing */
344 ParseFieldW (wTemp, 1, wTemp, MAX_PATH);
345 PathUnquoteSpacesW(wTemp);
346
347 if (!wcscmp(L"%1", wTemp)) /* icon is in the file */
348 {
349 ILGetDisplayNameExW(psf, pidl, wTemp, ILGDN_FORPARSING);
350 icon_idx = 0;
351
352 INT ret = PrivateExtractIconsW(wTemp, 0, 0, 0, NULL, NULL, 0, 0);
353 if (ret <= 0)
354 {
355 StringCbCopyW(wTemp, sizeof(wTemp), swShell32Name);
356 if (lstrcmpiW(pExtension, L".exe") == 0 || lstrcmpiW(pExtension, L".scr") == 0)
357 icon_idx = -IDI_SHELL_EXE;
358 else
359 icon_idx = -IDI_SHELL_DOCUMENT;
360 }
361 }
362
363 initIcon->SetNormalIcon(wTemp, icon_idx);
364 }
365 else
366 {
367 initIcon->SetNormalIcon(swShell32Name, 0);
368 }
369
370 if (hkey)
371 RegCloseKey(hkey);
372 }
373
374 return initIcon->QueryInterface(iid, ppvOut);
375}
376
377/*
378CFileSysEnum should do an initial FindFirstFile and do a FindNextFile as each file is
379returned by Next. When the enumerator is created, it can do numerous additional operations
380including formatting a drive, reconnecting a network share drive, and requesting a disk
381be inserted in a removable drive.
382*/
383
384
386 public CEnumIDListBase
387{
388private:
390 {
391#define SUPER_HIDDEN (FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM)
392
393 // Does it need special handling because it is hidden?
394 if (FindData.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN)
395 {
396 DWORD dwHidden = FindData.dwFileAttributes & SUPER_HIDDEN;
397
398 // Is it hidden, but are we not asked to include hidden?
399 if (dwHidden == FILE_ATTRIBUTE_HIDDEN && !(dwFlags & SHCONTF_INCLUDEHIDDEN))
400 return S_OK;
401
402 // Is it a system file, but are we not asked to include those?
403 if (dwHidden == SUPER_HIDDEN && !(dwFlags & SHCONTF_INCLUDESUPERHIDDEN))
404 return S_OK;
405 }
406
407 BOOL bDirectory = (FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
408
409 HRESULT hr;
410 if (bDirectory)
411 {
412 // Skip the current and parent directory nodes
413 if (!strcmpW(FindData.cFileName, L".") || !strcmpW(FindData.cFileName, L".."))
414 return S_OK;
415
416 // Does this directory need special handling?
417 if ((FindData.dwFileAttributes & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)) != 0)
418 {
419 WCHAR Tmp[MAX_PATH];
420 CLSID clsidFolder;
421
422 PathCombineW(Tmp, sParentDir, FindData.cFileName);
423
424 hr = SHELL32_GetCLSIDForDirectory(Tmp, L"CLSID", &clsidFolder);
425 if (SUCCEEDED(hr))
426 {
427 ERR("Got CLSID override for '%S'\n", Tmp);
428 }
429 }
430 }
431 else
432 {
433 CLSID clsidFile;
434 LPWSTR pExtension = PathFindExtensionW(FindData.cFileName);
435 if (pExtension)
436 {
437 // FIXME: Cache this?
438 hr = GetCLSIDForFileTypeFromExtension(pExtension, L"CLSID", &clsidFile);
439 if (hr == S_OK)
440 {
441 HKEY hkey;
442 hr = SHRegGetCLSIDKeyW(clsidFile, L"ShellFolder", FALSE, FALSE, &hkey);
443 if (SUCCEEDED(hr))
444 {
445 ::RegCloseKey(hkey);
446
447 // This should be presented as directory!
448 bDirectory = TRUE;
449 TRACE("Treating '%S' as directory!\n", FindData.cFileName);
450 }
451 }
452 }
453 }
454
455 LPITEMIDLIST pidl = NULL;
456 if (bDirectory)
457 {
458 if (dwFlags & SHCONTF_FOLDERS)
459 {
460 TRACE("(%p)-> (folder=%s)\n", this, debugstr_w(FindData.cFileName));
461 pidl = _ILCreateFromFindDataW(&FindData);
462 }
463 }
464 else
465 {
466 if (dwFlags & SHCONTF_NONFOLDERS)
467 {
468 TRACE("(%p)-> (file =%s)\n", this, debugstr_w(FindData.cFileName));
469 pidl = _ILCreateFromFindDataW(&FindData);
470 }
471 }
472
473 if (pidl && !AddToEnumList(pidl))
474 {
476 return E_FAIL;
477 }
478
479 return S_OK;
480 }
481
482public:
484 {
485
486 }
487
489 {
490 }
491
493 {
494 TRACE("(%p)->(path=%s flags=0x%08x)\n", this, debugstr_w(sPathTarget), dwFlags);
495
496 if (!sPathTarget || !sPathTarget[0])
497 {
498 WARN("No path for CFileSysEnum, empty result!\n");
499 return S_FALSE;
500 }
501
502 WCHAR szFindPattern[MAX_PATH];
503 HRESULT hr = StringCchCopyW(szFindPattern, _countof(szFindPattern), sPathTarget);
505 return hr;
506
507 /* FIXME: UNSAFE CRAP */
508 PathAddBackslashW(szFindPattern);
509
510 hr = StringCchCatW(szFindPattern, _countof(szFindPattern), L"*.*");
512 return hr;
513
514
515 WIN32_FIND_DATAW FindData;
516 HANDLE hFind = FindFirstFileW(szFindPattern, &FindData);
517 if (hFind == INVALID_HANDLE_VALUE)
519
520 do
521 {
522 hr = _AddFindResult(sPathTarget, FindData, dwFlags);
523
525 break;
526
527 } while(FindNextFileW(hFind, &FindData));
528
529 if (SUCCEEDED(hr))
530 {
531 DWORD dwError = GetLastError();
532 if (dwError != ERROR_NO_MORE_FILES)
533 {
534 hr = HRESULT_FROM_WIN32(dwError);
536 }
537 }
538 TRACE("(%p)->(hr=0x%08x)\n", this, hr);
539 FindClose(hFind);
540 return hr;
541 }
542
544 COM_INTERFACE_ENTRY_IID(IID_IEnumIDList, IEnumIDList)
546};
547
548
549/***********************************************************************
550 * IShellFolder implementation
551 */
552
554{
555 m_pclsid = &CLSID_ShellFSFolder;
559}
560
562{
563 TRACE("-- destroying IShellFolder(%p)\n", this);
564
567}
568
569static const shvheader GenericSFHeader[] = {
575 {IDS_SHV_COLUMN_COMMENTS, SHCOLSTATE_TYPE_STR | SHCOLSTATE_SLOW, LVCFMT_LEFT, 10}, // We don't currently support comments but CRegFolder does
576};
577
578#define GENERICSHELLVIEWCOLUMNS _countof(GenericSFHeader)
579
581{
582 if (iColumn >= _countof(GenericSFHeader))
583 return E_INVALIDARG;
584
585 sd.fmt = GenericSFHeader[iColumn].fmt;
586 sd.cxChar = GenericSFHeader[iColumn].cxChar;
587 return SHSetStrRet(&sd.str, GenericSFHeader[iColumn].colnameid);
588}
589
591{
592 if (iColumn >= _countof(GenericSFHeader))
593 return E_INVALIDARG;
594
595 csFlags = GenericSFHeader[iColumn].colstate;
596 return S_OK;
597}
598
600{
601 WCHAR wszCLSIDValue[CHARS_IN_GUID];
602 WCHAR wszDesktopIni[MAX_PATH];
603
604 StringCchCopyW(wszDesktopIni, MAX_PATH, pwszDir);
605 StringCchCatW(wszDesktopIni, MAX_PATH, L"\\desktop.ini");
606
607 if (GetPrivateProfileStringW(L".ShellClassInfo",
608 KeyName,
609 L"",
610 wszCLSIDValue,
612 wszDesktopIni))
613 {
614 return CLSIDFromString(wszCLSIDValue, pclsidFolder);
615 }
616 return E_FAIL;
617}
618
620{
621 DWORD dwFileAttributes, dwShellAttributes;
622
623 if (!_ILIsFolderOrFile(pidl))
624 {
625 ERR("Got wrong type of pidl!\n");
626 *pdwAttributes &= SFGAO_CANLINK;
627 return S_OK;
628 }
629
631
632 /* Set common attributes */
633 dwShellAttributes = SFGAO_CANCOPY | SFGAO_CANMOVE | SFGAO_CANLINK | SFGAO_CANRENAME | SFGAO_CANDELETE |
634 SFGAO_HASPROPSHEET | SFGAO_DROPTARGET | SFGAO_FILESYSTEM;
635
636 BOOL bDirectory = (dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
637
638 if (SFGAO_VALIDATE & *pdwAttributes)
639 {
640 STRRET strret;
641 LPWSTR path;
642 if (SUCCEEDED(psf->GetDisplayNameOf(pidl, SHGDN_FORPARSING, &strret)) &&
643 SUCCEEDED(StrRetToStrW(&strret, pidl, &path)))
644 {
645 BOOL exists = PathFileExistsW(path);
646 SHFree(path);
647 if (!exists)
648 return E_FAIL;
649 }
650 }
651
652 if (!bDirectory)
653 {
654 // https://git.reactos.org/?p=reactos.git;a=blob;f=dll/shellext/zipfldr/res/zipfldr.rgs;hb=032b5aacd233cd7b83ab6282aad638c161fdc400#l9
655 WCHAR szFileName[MAX_PATH];
656 LPWSTR pExtension;
657 BOOL hasName = _ILSimpleGetTextW(pidl, szFileName, _countof(szFileName));
658 dwShellAttributes |= SFGAO_STREAM;
659
660 // Vista+ feature: Hidden files with a leading tilde treated as super-hidden
661 // See https://devblogs.microsoft.com/oldnewthing/20170526-00/?p=96235
662 if (hasName && szFileName[0] == '~' && (dwFileAttributes & FILE_ATTRIBUTE_HIDDEN))
663 dwShellAttributes |= SFGAO_HIDDEN | SFGAO_SYSTEM;
664
665 if (hasName && (pExtension = PathFindExtensionW(szFileName)))
666 {
667 CLSID clsidFile;
668 // FIXME: Cache this?
669 HRESULT hr = GetCLSIDForFileTypeFromExtension(pExtension, L"CLSID", &clsidFile);
670 if (hr == S_OK)
671 {
672 HKEY hkey;
673 hr = SHRegGetCLSIDKeyW(clsidFile, L"ShellFolder", FALSE, FALSE, &hkey);
674 if (SUCCEEDED(hr))
675 {
677 DWORD dwSize = sizeof(dwAttributes);
679
681 if (Status == STATUS_SUCCESS)
682 {
683 TRACE("Augmenting '%S' with dwAttributes=0x%x\n", szFileName, dwAttributes);
684 dwShellAttributes |= dwAttributes;
685 }
686 ::RegCloseKey(hkey);
687
688 // This should be presented as directory!
689 bDirectory = (dwAttributes & SFGAO_FOLDER) != 0 || dwAttributes == 0;
690 TRACE("Treating '%S' as directory!\n", szFileName);
691 }
692 }
693 }
694 }
695
696 // This is a directory
697 if (bDirectory)
698 {
699 dwShellAttributes |= (SFGAO_FOLDER | /*SFGAO_HASSUBFOLDER |*/ SFGAO_STORAGE);
700
701 // Is this a real directory?
703 {
704 dwShellAttributes |= (SFGAO_FILESYSANCESTOR | SFGAO_STORAGEANCESTOR);
705 }
706 }
707
709 dwShellAttributes |= SFGAO_HIDDEN | SFGAO_GHOSTED;
710
712 dwShellAttributes |= SFGAO_READONLY;
713
715 dwShellAttributes |= SFGAO_SYSTEM;
716
718 dwShellAttributes |= SFGAO_COMPRESSED;
719
721 dwShellAttributes |= SFGAO_ENCRYPTED;
722
723 if ((SFGAO_NONENUMERATED & *pdwAttributes) && (dwFileAttributes & FILE_ATTRIBUTE_HIDDEN))
724 {
726 if ((!(shcf & SHCONTF_INCLUDEHIDDEN)) || ((dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) && !(shcf & SHCONTF_INCLUDESUPERHIDDEN)))
727 dwShellAttributes |= SFGAO_NONENUMERATED;
728 }
729
730 if (SFGAO_LINK & *pdwAttributes)
731 {
733
734 if (_ILGetExtension(pidl, ext, _countof(ext)) && !lstrcmpiW(ext, L"lnk"))
735 dwShellAttributes |= SFGAO_LINK;
736 }
737
738 if (SFGAO_HASSUBFOLDER & *pdwAttributes)
739 {
740 CComPtr<IShellFolder> psf2;
741 if (SUCCEEDED(psf->BindToObject(pidl, 0, IID_PPV_ARG(IShellFolder, &psf2))))
742 {
743 CComPtr<IEnumIDList> pEnumIL;
744 if (SUCCEEDED(psf2->EnumObjects(0, SHCONTF_FOLDERS, &pEnumIL)))
745 {
746 if (pEnumIL->Skip(1) == S_OK)
747 dwShellAttributes |= SFGAO_HASSUBFOLDER;
748 }
749 }
750 }
751
752 *pdwAttributes = dwShellAttributes;
753
754 TRACE ("-- 0x%08x\n", *pdwAttributes);
755 return S_OK;
756}
757
758// This method is typically invoked from SHSimpleIDListFromPathA/W.
760 _In_ LPOLESTR lpszDisplayName,
762 _Out_ LPITEMIDLIST *ppidl)
763{
764 HRESULT hr;
765 LPWSTR pchNext = lpszDisplayName;
766
767 *ppidl = NULL;
768
769 const DWORD finalattr = pFind->dwFileAttributes;
770 const DWORD finalsizelo = pFind->nFileSizeLow;
771 LPITEMIDLIST pidl;
772 for (hr = S_OK; SUCCEEDED(hr); hr = SHILAppend(pidl, ppidl))
773 {
774 hr = Shell_NextElement(&pchNext, pFind->cFileName, _countof(pFind->cFileName), FALSE);
775 if (hr != S_OK)
776 break;
777
778 pFind->dwFileAttributes = pchNext ? FILE_ATTRIBUTE_DIRECTORY : finalattr;
779 pFind->nFileSizeLow = pchNext ? 0 : finalsizelo;
780 pidl = _ILCreateFromFindDataW(pFind);
781 if (!pidl)
782 {
784 break;
785 }
786 }
787
788 if (SUCCEEDED(hr))
789 return S_OK;
790
791 if (*ppidl)
792 {
793 ILFree(*ppidl);
794 *ppidl = NULL;
795 }
796
797 return hr;
798}
799
801{
804 PathAppendW(szPath, pszName);
805
806 HANDLE hFind = ::FindFirstFileW(szPath, pFind);
807 if (hFind == INVALID_HANDLE_VALUE)
808 return FALSE;
809
810 ::FindClose(hFind);
811 return TRUE;
812}
813
815{
816 *ppidl = NULL;
817
818 if (PathIsDosDevice(pszName))
820
821 WIN32_FIND_DATAW FindData = { 0 };
822
823 HRESULT hr = S_OK;
824 if (attrs == ULONG_MAX) // Invalid attributes
825 {
826 if (!_GetFindDataFromName(pszName, &FindData))
828 }
829 else // Pretend as an item of attrs
830 {
831 StringCchCopyW(FindData.cFileName, _countof(FindData.cFileName), pszName);
832 FindData.dwFileAttributes = attrs;
833 }
834
835 if (FAILED(hr))
836 return hr;
837
838 *ppidl = _ILCreateFromFindDataW(&FindData);
839 if (!*ppidl)
840 return E_OUTOFMEMORY;
841
842 return S_OK;
843}
844
845/**************************************************************************
846* CFSFolder::ParseDisplayName {SHELL32}
847*
848* Parse a display name.
849*
850* PARAMS
851* hwndOwner [in] Parent window for any message's
852* pbc [in] optional FileSystemBindData context
853* lpszDisplayName [in] Unicode displayname.
854* pchEaten [out] (unicode) characters processed
855* ppidl [out] complex pidl to item
856* pdwAttributes [out] items attributes
857*
858* NOTES
859* Every folder tries to parse only its own (the leftmost) pidl and creates a
860* subfolder to evaluate the remaining parts.
861* Now we can parse into namespaces implemented by shell extensions
862*
863* Behaviour on win98: lpszDisplayName=NULL -> crash
864* lpszDisplayName="" -> returns mycoputer-pidl
865*
866* FIXME
867* pdwAttributes is not set
868* pchEaten is not set like in windows
869*/
871 LPBC pbc,
872 LPOLESTR lpszDisplayName,
873 DWORD *pchEaten, PIDLIST_RELATIVE *ppidl,
874 DWORD *pdwAttributes)
875{
876 TRACE ("(%p)->(HWND=%p,%p,%p=%s,%p,pidl=%p,%p)\n",
877 this, hwndOwner, pbc, lpszDisplayName, debugstr_w (lpszDisplayName),
878 pchEaten, ppidl, pdwAttributes);
879
880 if (!ppidl)
881 return E_INVALIDARG;
882
883 *ppidl = NULL;
884
885 if (!lpszDisplayName)
886 return E_INVALIDARG;
887
888 HRESULT hr;
889 WIN32_FIND_DATAW FindData;
890 if (SHIsFileSysBindCtx(pbc, &FindData) == S_OK)
891 {
892 CComHeapPtr<ITEMIDLIST> pidlTemp;
893 hr = _ParseSimple(lpszDisplayName, &FindData, &pidlTemp);
894 if (SUCCEEDED(hr) && pdwAttributes && *pdwAttributes)
895 {
896 LPCITEMIDLIST pidlLast = ILFindLastID(pidlTemp);
897 GetAttributesOf(1, &pidlLast, pdwAttributes);
898 }
899
900 if (SUCCEEDED(hr))
901 *ppidl = pidlTemp.Detach();
902 }
903 else
904 {
905 INT cchElement = lstrlenW(lpszDisplayName) + 1;
906 LPWSTR pszElement = (LPWSTR)_alloca(cchElement * sizeof(WCHAR));
907 LPWSTR pchNext = lpszDisplayName;
908 hr = Shell_NextElement(&pchNext, pszElement, cchElement, TRUE);
909 if (FAILED(hr))
910 return hr;
911
912 hr = _CreateIDListFromName(pszElement, ULONG_MAX, pbc, ppidl);
913 if (FAILED(hr))
914 {
915 if (pchNext) // Is there the next element?
916 {
917 // pszElement seems like a directory
918 if (_GetFindDataFromName(pszElement, &FindData) &&
919 (FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
920 {
921 hr = _CreateIDListFromName(pszElement, FILE_ATTRIBUTE_DIRECTORY, pbc, ppidl);
922 }
923 }
924 else
925 {
926 // pszElement seems like a non-directory
929 (BindCtx_GetMode(pbc, 0) & STGM_CREATE))
930 {
931 // Pretend like a normal file
932 hr = _CreateIDListFromName(pszElement, FILE_ATTRIBUTE_NORMAL, pbc, ppidl);
933 }
934 }
935 }
936
937 if (SUCCEEDED(hr))
938 {
939 if (pchNext) // Is there next?
940 {
941 CComPtr<IShellFolder> psfChild;
942 hr = BindToObject(*ppidl, pbc, IID_PPV_ARG(IShellFolder, &psfChild));
943 if (FAILED(hr))
944 return hr;
945
946 DWORD chEaten;
947 CComHeapPtr<ITEMIDLIST> pidlChild;
948 hr = psfChild->ParseDisplayName(hwndOwner, pbc, pchNext, &chEaten, &pidlChild,
949 pdwAttributes);
950
951 // Append pidlChild to ppidl
952 if (SUCCEEDED(hr))
953 hr = SHILAppend(pidlChild.Detach(), ppidl);
954 }
955 else if (pdwAttributes && *pdwAttributes)
956 {
957 GetAttributesOf(1, (LPCITEMIDLIST*)ppidl, pdwAttributes);
958 }
959 }
960 }
961
962 TRACE("(%p)->(-- pidl=%p ret=0x%08x)\n", this, ppidl ? *ppidl : 0, hr);
963
964 return hr;
965}
966
967/**************************************************************************
968* CFSFolder::EnumObjects
969* PARAMETERS
970* HWND hwndOwner, //[in ] Parent Window
971* DWORD grfFlags, //[in ] SHCONTF enumeration mask
972* LPENUMIDLIST* ppenumIDList //[out] IEnumIDList interface
973*/
975 HWND hwndOwner,
977 LPENUMIDLIST *ppEnumIDList)
978{
979 return ShellObjectCreatorInit<CFileSysEnum>(m_sPathTarget, dwFlags, IID_PPV_ARG(IEnumIDList, ppEnumIDList));
980}
981
982/**************************************************************************
983* CFSFolder::BindToObject
984* PARAMETERS
985* LPCITEMIDLIST pidl, //[in ] relative pidl to open
986* LPBC pbc, //[in ] optional FileSystemBindData context
987* REFIID riid, //[in ] Initial Interface
988* LPVOID* ppvObject //[out] Interface*
989*/
992 LPBC pbc,
993 REFIID riid,
994 LPVOID * ppvOut)
995{
996 TRACE("(%p)->(pidl=%p,%p,%s,%p)\n", this, pidl, pbc,
997 shdebugstr_guid(&riid), ppvOut);
998
999 CComPtr<IShellFolder> pSF;
1000 HRESULT hr;
1001
1002 if (!m_pidlRoot || !ppvOut || !pidl || !pidl->mkid.cb)
1003 {
1004 ERR("CFSFolder::BindToObject: Invalid parameters\n");
1005 return E_INVALIDARG;
1006 }
1007
1008 /* Get the pidl data */
1010 WCHAR szNameBuf[MAX_PATH];
1011 LPCWSTR pszName = GetItemFileName(pidl, szNameBuf, _countof(szNameBuf));
1012 if (!pszName)
1013 {
1014 ERR("CFSFolder::BindToObject: Invalid pidl!\n");
1015 return E_INVALIDARG;
1016 }
1017
1018 *ppvOut = NULL;
1019
1020 /* Create the target folder info */
1021 PERSIST_FOLDER_TARGET_INFO pfti = {0};
1022 pfti.dwAttributes = -1;
1023 pfti.csidl = -1;
1025
1026 /* Get the CLSID to bind to */
1027 CLSID clsidFolder;
1028 if (_ILIsFolder(pidl))
1029 {
1030 if ((pData->uFileAttribs & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)) != 0)
1031 {
1032 hr = SHELL32_GetCLSIDForDirectory(pfti.szTargetParsingName, L"CLSID", &clsidFolder);
1033
1034 if (SUCCEEDED(hr))
1035 {
1036 /* We got a GUID from a desktop.ini, let's try it */
1037 hr = SHELL32_BindToSF(m_pidlRoot, &pfti, pidl, &clsidFolder, riid, ppvOut);
1038 if (SUCCEEDED(hr))
1039 {
1040 TRACE("-- returning (%p) %08x, (%s)\n", *ppvOut, hr, wine_dbgstr_guid(&clsidFolder));
1041 return hr;
1042 }
1043
1044 /* Something went wrong, re-try it with a normal ShellFSFolder */
1045 ERR("CFSFolder::BindToObject: %s failed to bind, using fallback (0x%08x)\n", wine_dbgstr_guid(&clsidFolder), hr);
1046 }
1047 }
1048 /* No system folder or the custom class failed */
1049 clsidFolder = CLSID_ShellFSFolder;
1050 }
1051 else
1052 {
1053 hr = GetCLSIDForFileType(pidl, L"CLSID", &clsidFolder);
1054 if (hr == S_FALSE)
1056 if (hr != S_OK)
1057 return hr;
1058 }
1059
1060 hr = SHELL32_BindToSF(m_pidlRoot, &pfti, pidl, &clsidFolder, riid, ppvOut);
1062 return hr;
1063
1064 TRACE ("-- returning (%p) %08x\n", *ppvOut, hr);
1065
1066 return S_OK;
1067
1068}
1069
1070/**************************************************************************
1071* CFSFolder::BindToStorage
1072* PARAMETERS
1073* LPCITEMIDLIST pidl, //[in ] complex pidl to store
1074* LPBC pbc, //[in ] reserved
1075* REFIID riid, //[in ] Initial storage interface
1076* LPVOID* ppvObject //[out] Interface* returned
1077*/
1079 PCUIDLIST_RELATIVE pidl,
1080 LPBC pbcReserved,
1081 REFIID riid,
1082 LPVOID *ppvOut)
1083{
1084 FIXME("(%p)->(pidl=%p,%p,%s,%p) stub\n", this, pidl, pbcReserved,
1085 shdebugstr_guid (&riid), ppvOut);
1086
1087 *ppvOut = NULL;
1088 return E_NOTIMPL;
1089}
1090
1092{
1093 BOOL bIsFolder1 = _ILIsFolder(pidl1), bIsFolder2 = _ILIsFolder(pidl2);
1094 // When sorting between a File and a Folder, the Folder gets sorted first
1095 if (bIsFolder1 != bIsFolder2)
1096 {
1097 // ...but only if neither of them were generated by SHSimpleIDListFromPath
1098 // because in that case we cannot tell if it's a file or a folder.
1099 if (pidl1 && IsRealItem(*pidl1) && pidl2 && IsRealItem(*pidl2))
1100 return MAKE_COMPARE_HRESULT(bIsFolder1 ? -1 : 1);
1101 }
1103}
1104
1105/**************************************************************************
1106* CFSFolder::CompareIDs
1107*/
1108
1110 PCUIDLIST_RELATIVE pidl1,
1111 PCUIDLIST_RELATIVE pidl2)
1112{
1113 WCHAR szNameBuf1[MAX_PATH], szNameBuf2[_countof(szNameBuf1)];
1114 LPCWSTR pszName1 = GetItemFileName(pidl1, szNameBuf1, _countof(szNameBuf1));
1115 LPCWSTR pszName2 = GetItemFileName(pidl2, szNameBuf2, _countof(szNameBuf2));
1116 if (!pszName1 || !pszName2 || LOWORD(lParam) >= GENERICSHELLVIEWCOLUMNS)
1117 return E_INVALIDARG;
1118
1119 LPPIDLDATA pData1 = _ILGetDataPointer(pidl1);
1120 LPPIDLDATA pData2 = _ILGetDataPointer(pidl2);
1121 LPWSTR pExtension1, pExtension2;
1122
1123 HRESULT hr = CompareSortFoldersFirst(pidl1, pidl2);
1124 if (SUCCEEDED(hr))
1125 return hr;
1126 int result = 0;
1127 switch (LOWORD(lParam))
1128 {
1129 case SHFSF_COL_NAME:
1130 result = _wcsicmp(pszName1, pszName2);
1131 break;
1132 case SHFSF_COL_SIZE:
1133 if (pData1->u.file.dwFileSize > pData2->u.file.dwFileSize)
1134 result = 1;
1135 else if (pData1->u.file.dwFileSize < pData2->u.file.dwFileSize)
1136 result = -1;
1137 else
1138 result = 0;
1139 break;
1140 case SHFSF_COL_TYPE:
1141 // FIXME: Compare the type strings from SHGetFileInfo
1142 pExtension1 = PathFindExtensionW(pszName1);
1143 pExtension2 = PathFindExtensionW(pszName2);
1144 result = _wcsicmp(pExtension1, pExtension2);
1145 break;
1146 case SHFSF_COL_MDATE:
1147 result = pData1->u.file.uFileDate - pData2->u.file.uFileDate;
1148 if (result == 0)
1149 result = pData1->u.file.uFileTime - pData2->u.file.uFileTime;
1150 break;
1151 case SHFSF_COL_FATTS:
1152 return SHELL32_CompareDetails(this, lParam, pidl1, pidl2);
1153 case SHFSF_COL_COMMENT:
1154 result = 0;
1155 break;
1156 default:
1157 if (_ILIsPidlSimple(pidl1) || _ILIsPidlSimple(pidl2))
1158 ERR("Unknown column %u, can't compare\n", LOWORD(lParam));
1159 else
1160 TRACE("Unknown column %u, deferring to the subfolder\n", LOWORD(lParam));
1161 }
1162
1163 if (result == 0)
1164 return SHELL32_CompareChildren(this, lParam, pidl1, pidl2);
1165
1167}
1168
1169/**************************************************************************
1170* CFSFolder::CreateViewObject
1171*/
1173 REFIID riid, LPVOID * ppvOut)
1174{
1175 CComPtr<IShellView> pShellView;
1177
1178 TRACE ("(%p)->(hwnd=%p,%s,%p)\n", this, hwndOwner, shdebugstr_guid (&riid),
1179 ppvOut);
1180
1181 if (ppvOut)
1182 {
1183 *ppvOut = NULL;
1184
1185 BOOL bIsDropTarget = IsEqualIID (riid, IID_IDropTarget);
1186 BOOL bIsShellView = !bIsDropTarget && IsEqualIID (riid, IID_IShellView);
1187
1188 if (bIsDropTarget || bIsShellView)
1189 {
1190 DWORD dwDirAttributes = _ILGetFileAttributes(ILFindLastID(m_pidlRoot), NULL, 0);
1191
1192 if ((dwDirAttributes & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)) != 0)
1193 {
1194 CLSID clsidFolder;
1195 hr = SHELL32_GetCLSIDForDirectory(m_sPathTarget, L"UICLSID", &clsidFolder);
1196 if (SUCCEEDED(hr))
1197 {
1198 CComPtr<IPersistFolder> spFolder;
1199 hr = SHCoCreateInstance(NULL, &clsidFolder, NULL, IID_PPV_ARG(IPersistFolder, &spFolder));
1200 if (!FAILED_UNEXPECTEDLY(hr))
1201 {
1202 hr = spFolder->Initialize(m_pidlRoot);
1203
1204 if (!FAILED_UNEXPECTEDLY(hr))
1205 {
1206 hr = spFolder->QueryInterface(riid, ppvOut);
1207 }
1208 }
1209 }
1210 else
1211 {
1212 // No desktop.ini, or no UICLSID present, continue as if nothing happened
1213 hr = E_INVALIDARG;
1214 }
1215 }
1216 }
1217
1218 if (!SUCCEEDED(hr))
1219 {
1220 // No UICLSID handler found, continue to the default handlers
1221 if (bIsDropTarget)
1222 {
1224 }
1225 else if (IsEqualIID (riid, IID_IContextMenu))
1226 {
1227 HKEY hKeys[16];
1228 UINT cKeys = 0;
1229 AddClassKeyToArray(L"Directory\\Background", hKeys, &cKeys);
1230
1231 DEFCONTEXTMENU dcm;
1232 dcm.hwnd = hwndOwner;
1233 dcm.pcmcb = this;
1234 dcm.pidlFolder = m_pidlRoot;
1235 dcm.psf = this;
1236 dcm.cidl = 0;
1237 dcm.apidl = NULL;
1238 dcm.cKeys = cKeys;
1239 dcm.aKeys = hKeys;
1241 hr = SHCreateDefaultContextMenu (&dcm, riid, ppvOut);
1242 }
1243 else if (bIsShellView)
1244 {
1245 SFV_CREATE sfvparams = {sizeof(SFV_CREATE), this, NULL, this};
1246 hr = SHCreateShellFolderView(&sfvparams, (IShellView**)ppvOut);
1247 }
1248 else
1249 {
1250 hr = E_INVALIDARG;
1251 }
1252 }
1253 }
1254 TRACE("-- (%p)->(interface=%p)\n", this, ppvOut);
1255 return hr;
1256}
1257
1258/**************************************************************************
1259* CFSFolder::GetAttributesOf
1260*
1261* PARAMETERS
1262* UINT cidl, //[in ] num elements in pidl array
1263* LPCITEMIDLIST* apidl, //[in ] simple pidl array
1264* ULONG* rgfInOut) //[out] result array
1265*
1266*/
1268 PCUITEMID_CHILD_ARRAY apidl, DWORD * rgfInOut)
1269{
1270 HRESULT hr = S_OK;
1271
1272 if (!rgfInOut)
1273 return E_INVALIDARG;
1274 if (cidl && !apidl)
1275 return E_INVALIDARG;
1276
1277 if (*rgfInOut == 0)
1278 *rgfInOut = ~0;
1279
1280 if(cidl == 0)
1281 {
1283
1284 if (_ILIsFolderOrFile(rpidl))
1285 {
1286 SHELL32_GetFSItemAttributes(this, rpidl, rgfInOut);
1287 }
1288 else if (_ILIsDrive(rpidl))
1289 {
1290 IShellFolder *psfParent = NULL;
1292 if(SUCCEEDED(hr))
1293 {
1294 hr = psfParent->GetAttributesOf(1, &rpidl, (SFGAOF*)rgfInOut);
1295 psfParent->Release();
1296 }
1297 }
1298 else
1299 {
1300 ERR("Got and unknown pidl!\n");
1301 }
1302 }
1303 else
1304 {
1305 while (cidl > 0 && *apidl)
1306 {
1307 pdump(*apidl);
1308 if (_ILIsFolderOrFile(*apidl))
1309 SHELL32_GetFSItemAttributes(this, *apidl, rgfInOut);
1310 else
1311 ERR("Got an unknown type of pidl!!!\n");
1312 apidl++;
1313 cidl--;
1314 }
1315 }
1316 /* make sure SFGAO_VALIDATE is cleared, some apps depend on that */
1317 *rgfInOut &= ~SFGAO_VALIDATE;
1318
1319 TRACE("-- result=0x%08x\n", *rgfInOut);
1320
1321 return hr;
1322}
1323
1324/**************************************************************************
1325* CFSFolder::GetUIObjectOf
1326*
1327* PARAMETERS
1328* HWND hwndOwner, //[in ] Parent window for any output
1329* UINT cidl, //[in ] array size
1330* LPCITEMIDLIST* apidl, //[in ] simple pidl array
1331* REFIID riid, //[in ] Requested Interface
1332* UINT* prgfInOut, //[ ] reserved
1333* LPVOID* ppvObject) //[out] Resulting Interface
1334*
1335* NOTES
1336* This function gets asked to return "view objects" for one or more (multiple
1337* select) items:
1338* The viewobject typically is an COM object with one of the following
1339* interfaces:
1340* IExtractIcon,IDataObject,IContextMenu
1341* In order to support icon positions in the default Listview your DataObject
1342* must implement the SetData method (in addition to GetData :) - the shell
1343* passes a barely documented "Icon positions" structure to SetData when the
1344* drag starts, and GetData's it if the drop is in another explorer window that
1345* needs the positions.
1346*/
1348 UINT cidl, PCUITEMID_CHILD_ARRAY apidl,
1349 REFIID riid, UINT * prgfInOut,
1350 LPVOID * ppvOut)
1351{
1352 LPVOID pObj = NULL;
1354
1355 TRACE ("(%p)->(%p,%u,apidl=%p,%s,%p,%p)\n",
1356 this, hwndOwner, cidl, apidl, shdebugstr_guid (&riid), prgfInOut, ppvOut);
1357
1358 if (ppvOut)
1359 {
1360 *ppvOut = NULL;
1361
1362 if (cidl == 1 && _ILIsValue(apidl[0]))
1363 {
1364 hr = _CreateExtensionUIObject(apidl[0], riid, ppvOut);
1365 if(hr != S_FALSE)
1366 return hr;
1367 }
1368
1369 if (IsEqualIID(riid, IID_IContextMenu) && (cidl >= 1))
1370 {
1371 HKEY hKeys[16];
1372 UINT cKeys = 0;
1373 AddFSClassKeysToArray(cidl, apidl, hKeys, &cKeys);
1374
1375 DEFCONTEXTMENU dcm;
1376 dcm.hwnd = hwndOwner;
1377 dcm.pcmcb = this;
1378 dcm.pidlFolder = m_pidlRoot;
1379 dcm.psf = this;
1380 dcm.cidl = cidl;
1381 dcm.apidl = apidl;
1382 dcm.cKeys = cKeys;
1383 dcm.aKeys = hKeys;
1385 hr = SHCreateDefaultContextMenu (&dcm, riid, &pObj);
1386 }
1387 else if (IsEqualIID (riid, IID_IDataObject))
1388 {
1389 if (cidl >= 1)
1390 {
1391 hr = IDataObject_Constructor (hwndOwner, m_pidlRoot, apidl, cidl, TRUE, (IDataObject **)&pObj);
1392 }
1393 else
1394 {
1395 hr = E_INVALIDARG;
1396 }
1397 }
1398 else if ((IsEqualIID (riid, IID_IExtractIconA) || IsEqualIID (riid, IID_IExtractIconW)) && (cidl == 1))
1399 {
1400 if (_ILIsValue(apidl[0]))
1401 hr = _GetIconHandler(apidl[0], riid, (LPVOID*)&pObj);
1402 if (hr != S_OK)
1403 hr = CFSExtractIcon_CreateInstance(this, apidl[0], riid, &pObj);
1404 }
1405 else if (IsEqualIID (riid, IID_IDropTarget))
1406 {
1407 /* only interested in attempting to bind to shell folders, not files (except exe), so if we fail, rebind to root */
1408 if (cidl != 1 || FAILED(hr = this->_GetDropTarget(apidl[0], (LPVOID*) &pObj)))
1409 {
1411 }
1412 }
1413 else
1414 hr = E_NOINTERFACE;
1415
1416 if (SUCCEEDED(hr) && !pObj)
1417 hr = E_OUTOFMEMORY;
1418
1419 *ppvOut = pObj;
1420 }
1421 TRACE("(%p)->hr=0x%08x\n", this, hr);
1422 return hr;
1423}
1424
1425/******************************************************************************
1426 * SHELL_FS_HideExtension [Internal]
1427 *
1428 * Query the registry if the filename extension of a given path should be
1429 * hidden.
1430 *
1431 * PARAMS
1432 * szPath [I] Relative or absolute path of a file
1433 *
1434 * RETURNS
1435 * TRUE, if the filename's extension should be hidden
1436 * FALSE, otherwise.
1437 */
1439{
1440 HKEY hKey;
1441 BOOL doHide = FALSE; /* The default value is FALSE (win98 at least) */
1442 LONG lError;
1443
1444 doHide = !SHELL_GetSetting(SSF_SHOWEXTENSIONS, fShowExtensions);
1445
1446 if (!doHide)
1447 {
1449 if (*DotExt != 0)
1450 {
1452 LONG classlen = sizeof(classname);
1453 lError = RegQueryValueW(HKEY_CLASSES_ROOT, DotExt, classname, &classlen);
1454 if (lError == ERROR_SUCCESS)
1455 {
1457 if (lError == ERROR_SUCCESS)
1458 {
1459 lError = RegQueryValueExW(hKey, L"NeverShowExt", NULL, NULL, NULL, NULL);
1460 if (lError == ERROR_SUCCESS)
1461 doHide = TRUE;
1462
1464 }
1465 }
1466 }
1467 }
1468
1469 return doHide;
1470}
1471
1473{
1474 /*FIXME: MSDN also mentions SHGDN_FOREDITING which is not yet handled. */
1475 if (!(dwFlags & SHGDN_FORPARSING) &&
1476 ((dwFlags & SHGDN_INFOLDER) || (dwFlags == SHGDN_NORMAL))) {
1477 if (SHELL_FS_HideExtension(szPath) && szPath[0] != '.')
1479 }
1480}
1481
1482/**************************************************************************
1483* CFSFolder::GetDisplayNameOf
1484* Retrieves the display name for the specified file object or subfolder
1485*
1486* PARAMETERS
1487* LPCITEMIDLIST pidl, //[in ] complex pidl to item
1488* DWORD dwFlags, //[in ] SHGNO formatting flags
1489* LPSTRRET lpName) //[out] Returned display name
1490*
1491* FIXME
1492* if the name is in the pidl the ret value should be a STRRET_OFFSET
1493*/
1494
1496 DWORD dwFlags, LPSTRRET strRet)
1497{
1498 if (!strRet)
1499 return E_INVALIDARG;
1500
1501 /* If it is a complex pidl, let the child handle it */
1502 if (!_ILIsPidlSimple (pidl)) /* complex pidl */
1503 {
1504 return SHELL32_GetDisplayNameOfChild(this, pidl, dwFlags, strRet);
1505 }
1506 else if (pidl && !pidl->mkid.cb) /* empty pidl */
1507 {
1508 /* If it is an empty pidl return only the path of the folder */
1512 {
1513 return SHSetStrRet(strRet, m_sPathTarget);
1514 }
1515 return E_INVALIDARG;
1516 }
1517
1518 int len = 0;
1519 LPWSTR pszPath = (LPWSTR)CoTaskMemAlloc((MAX_PATH + 1) * sizeof(WCHAR));
1520 if (!pszPath)
1521 return E_OUTOFMEMORY;
1522
1526 {
1527 lstrcpynW(pszPath, m_sPathTarget, MAX_PATH);
1528 PathAddBackslashW(pszPath);
1529 len = wcslen(pszPath);
1530 }
1531 _ILSimpleGetTextW(pidl, pszPath + len, MAX_PATH + 1 - len);
1533
1534 strRet->uType = STRRET_WSTR;
1535 strRet->pOleStr = pszPath;
1536
1537 TRACE ("-- (%p)->(%s)\n", this, strRet->uType == STRRET_CSTR ? strRet->cStr : debugstr_w(strRet->pOleStr));
1538 return S_OK;
1539}
1540
1541/**************************************************************************
1542* CFSFolder::SetNameOf
1543* Changes the name of a file object or subfolder, possibly changing its item
1544* identifier in the process.
1545*
1546* PARAMETERS
1547* HWND hwndOwner, //[in ] Owner window for output
1548* LPCITEMIDLIST pidl, //[in ] simple pidl of item to change
1549* LPCOLESTR lpszName, //[in ] the items new display name
1550* DWORD dwFlags, //[in ] SHGNO formatting flags
1551* LPITEMIDLIST* ppidlOut) //[out] simple pidl returned
1552*/
1554 HWND hwndOwner,
1555 PCUITEMID_CHILD pidl,
1556 LPCOLESTR lpName,
1557 DWORD dwFlags,
1558 PITEMID_CHILD *pPidlOut)
1559{
1560 WCHAR szSrc[MAX_PATH + 1], szDest[MAX_PATH + 1], szNameBuf[MAX_PATH];
1561 BOOL bIsFolder = _ILIsFolder (ILFindLastID (pidl));
1562
1563 TRACE ("(%p)->(%p,pidl=%p,%s,%u,%p)\n", this, hwndOwner, pidl,
1564 debugstr_w (lpName), dwFlags, pPidlOut);
1565
1566 LPCWSTR pszName = GetItemFileName(pidl, szNameBuf, _countof(szNameBuf));
1567 if (!pszName)
1568 {
1569 ERR("Got garbage pidl:\n");
1570 pdump_always(pidl);
1571 return E_INVALIDARG;
1572 }
1573
1574 /* build source path */
1575 PathCombineW(szSrc, m_sPathTarget, pszName);
1576
1577 /* build destination path */
1580 else
1581 lstrcpynW(szDest, lpName, MAX_PATH);
1582
1583 if (!(dwFlags & SHGDN_FORPARSING) && !bIsFolder && SHELL_FS_HideExtension(szSrc))
1584 {
1586 if (*ext)
1587 PathAddExtensionW(szDest, ext);
1588 }
1589
1590 HRESULT hr = S_OK;
1591 TRACE ("src=%s dest=%s\n", debugstr_w(szSrc), debugstr_w(szDest));
1592 if (!wcscmp(szSrc, szDest))
1593 {
1594 /* src and destination is the same */
1595 if (pPidlOut)
1596 hr = SHILClone(pidl, pPidlOut);
1597 }
1598 else if (MoveFileW(szSrc, szDest))
1599 {
1600 if (pPidlOut)
1601 hr = ParseDisplayName(hwndOwner, NULL, PathFindFileNameW(szDest), NULL, pPidlOut, NULL);
1602
1603 SHChangeNotify(bIsFolder ? SHCNE_RENAMEFOLDER : SHCNE_RENAMEITEM, SHCNF_PATHW, szSrc, szDest);
1604 }
1605 else
1606 {
1608 }
1609 return hr;
1610}
1611
1613{
1614 FIXME ("(%p)\n", this);
1615 return E_NOTIMPL;
1616}
1617
1619{
1620 FIXME ("(%p)\n", this);
1621 return E_NOTIMPL;
1622}
1623
1625 ULONG * pSort, ULONG * pDisplay)
1626{
1627 TRACE ("(%p)\n", this);
1628
1629 if (pSort)
1630 *pSort = 0;
1631 if (pDisplay)
1632 *pDisplay = 0;
1633
1634 return S_OK;
1635}
1636
1638 SHCOLSTATEF *pcsFlags)
1639{
1640 TRACE ("(%p)\n", this);
1641
1642 if (!pcsFlags)
1643 return E_INVALIDARG;
1644 else
1645 return GetDefaultFSColumnState(iColumn, *pcsFlags);
1646}
1647
1649 const SHCOLUMNID * pscid, VARIANT * pv)
1650{
1651 FIXME ("(%p)\n", this);
1652
1653 return E_NOTIMPL;
1654}
1655
1657 UINT iColumn, SHELLDETAILS * psd)
1658{
1659 HRESULT hr = E_FAIL;
1660
1661 TRACE ("(%p)->(%p %i %p)\n", this, pidl, iColumn, psd);
1662
1663 if (!psd || iColumn >= GENERICSHELLVIEWCOLUMNS)
1664 return E_INVALIDARG;
1665
1666 if (!pidl)
1667 {
1668 /* the header titles */
1669 return GetFSColumnDetails(iColumn, *psd);
1670 }
1671 else
1672 {
1673 FILETIME ft;
1674 hr = S_OK;
1675 psd->str.uType = STRRET_WSTR;
1676 if (iColumn != SHFSF_COL_NAME)
1677 {
1678 psd->str.pOleStr = (LPWSTR)CoTaskMemAlloc(MAX_PATH * sizeof(WCHAR));
1679 if (!psd->str.pOleStr)
1680 return E_OUTOFMEMORY;
1681 }
1682 /* the data from the pidl */
1683 switch (iColumn)
1684 {
1685 case SHFSF_COL_NAME:
1687 break;
1688 case SHFSF_COL_SIZE:
1689 _ILGetFileSize(pidl, psd->str.pOleStr, MAX_PATH);
1690 break;
1691 case SHFSF_COL_TYPE:
1693 break;
1694 case SHFSF_COL_MDATE:
1695 if (!_ILGetFileDateTime(pidl, &ft) || FAILED(FormatDateTime(ft, psd->str.pOleStr, MAX_PATH)))
1696 {
1697 *psd->str.pOleStr = UNICODE_NULL;
1698 hr = S_FALSE;
1699 }
1700 break;
1701 case SHFSF_COL_FATTS:
1703 break;
1704 case SHFSF_COL_COMMENT:
1705 psd->str.pOleStr[0] = UNICODE_NULL; // TODO: Extract comment from .lnk files? desktop.ini?
1706 break;
1707#if DBG
1708 default:
1709 ERR("Missing case for column %d\n", iColumn);
1710#else
1712#endif
1713 }
1714 }
1715
1716 return hr;
1717}
1718
1720 SHCOLUMNID * pscid)
1721{
1722 FIXME ("(%p)\n", this);
1723 return E_NOTIMPL;
1724}
1725
1726/************************************************************************
1727 * CFSFolder::GetClassID
1728 */
1730{
1731 TRACE ("(%p)\n", this);
1732
1733 if (!lpClassId)
1734 return E_POINTER;
1735
1736 *lpClassId = *m_pclsid;
1737
1738 return S_OK;
1739}
1740
1741/************************************************************************
1742 * CFSFolder::Initialize
1743 *
1744 * NOTES
1745 * m_sPathTarget is not set. Don't know how to handle in a non rooted environment.
1746 */
1748{
1749 WCHAR wszTemp[MAX_PATH];
1750
1751 TRACE ("(%p)->(%p)\n", this, pidl);
1752
1753 SHFree(m_pidlRoot); /* free the old pidl */
1754 m_pidlRoot = ILClone (pidl); /* set my pidl */
1755
1758
1759 /* set my path */
1760 HRESULT hr = E_FAIL;
1761 if (SHGetPathFromIDListW (pidl, wszTemp))
1762 hr = SHStrDupW(wszTemp, &m_sPathTarget);
1763
1764 TRACE ("--(%p)->(%s)\n", this, debugstr_w(m_sPathTarget));
1765 return hr;
1766}
1767
1768/**************************************************************************
1769 * CFSFolder::GetCurFolder
1770 */
1772{
1773 TRACE ("(%p)->(%p)\n", this, pidl);
1774
1775 if (!pidl)
1776 return E_POINTER;
1777
1778 *pidl = ILClone(m_pidlRoot);
1779 return S_OK;
1780}
1781
1782/**************************************************************************
1783 * CFSFolder::InitializeEx
1784 *
1785 * FIXME: error handling
1786 */
1788 const PERSIST_FOLDER_TARGET_INFO * ppfti)
1789{
1790 WCHAR wszTemp[MAX_PATH];
1791
1792 TRACE("(%p)->(%p,%p,%p)\n", this, pbc, pidlRootx, ppfti);
1793 if (ppfti)
1794 TRACE("--%p %s %s 0x%08x 0x%08x\n",
1796 debugstr_w (ppfti->szNetworkProvider), ppfti->dwAttributes,
1797 ppfti->csidl);
1798
1799 pdump (pidlRootx);
1800 if (ppfti && ppfti->pidlTargetFolder)
1801 pdump(ppfti->pidlTargetFolder);
1802
1803 if (m_pidlRoot)
1804 __SHFreeAndNil(&m_pidlRoot); /* free the old */
1805 if (m_sPathTarget)
1807
1808 /*
1809 * Root path and pidl
1810 */
1811 m_pidlRoot = ILClone(pidlRootx);
1812
1813 /*
1814 * the target folder is spezified in csidl OR pidlTargetFolder OR
1815 * szTargetParsingName
1816 */
1817 HRESULT hr = E_FAIL;
1818 if (ppfti)
1819 {
1820 if (ppfti->csidl != -1)
1821 {
1823 if (SHGetSpecialFolderPathW(0, wszTemp, ppfti->csidl, create))
1824 hr = SHStrDupW(wszTemp, &m_sPathTarget);
1825 }
1826 else if (ppfti->szTargetParsingName[0])
1827 {
1829 }
1830 else if (ppfti->pidlTargetFolder)
1831 {
1832 if (SHGetPathFromIDListW(ppfti->pidlTargetFolder, wszTemp))
1833 hr = SHStrDupW(wszTemp, &m_sPathTarget);
1834 }
1835 }
1836 TRACE("--(%p)->(target=%s)\n", this, debugstr_w(m_sPathTarget));
1838 return hr;
1839}
1840
1842{
1843 FIXME("(%p)->(%p)\n", this, ppfti);
1844 ZeroMemory(ppfti, sizeof (*ppfti));
1845 return E_NOTIMPL;
1846}
1847
1849{
1851
1852 sprintfW(buf, L"ShellEx\\{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
1853 riid.Data1, riid.Data2, riid.Data3,
1854 riid.Data4[0], riid.Data4[1], riid.Data4[2], riid.Data4[3],
1855 riid.Data4[4], riid.Data4[5], riid.Data4[6], riid.Data4[7]);
1856
1857 CLSID clsid;
1858 HRESULT hr;
1859
1860 hr = GetCLSIDForFileType(pidl, buf, &clsid);
1861 if (hr != S_OK)
1862 return hr;
1863
1864 hr = _CreateShellExtInstance(&clsid, pidl, riid, ppvOut);
1866 return hr;
1867
1868 return S_OK;
1869}
1870
1872{
1873 HRESULT hr;
1874
1875 TRACE("CFSFolder::_GetDropTarget entered\n");
1876
1877 if (_ILIsFolder (pidl))
1878 {
1879 CComPtr<IShellFolder> psfChild;
1880 hr = this->BindToObject(pidl, NULL, IID_PPV_ARG(IShellFolder, &psfChild));
1882 return hr;
1883
1884 return psfChild->CreateViewObject(NULL, IID_IDropTarget, ppvOut);
1885 }
1886
1887 CLSID clsid;
1888 hr = GetCLSIDForFileType(pidl, L"shellex\\DropHandler", &clsid);
1889 if (hr != S_OK)
1890 return hr;
1891
1892 hr = _CreateShellExtInstance(&clsid, pidl, IID_IDropTarget, ppvOut);
1894 return S_FALSE;
1895
1896 return S_OK;
1897}
1898
1900{
1901 CLSID clsid;
1902 HRESULT hr;
1903
1904 hr = GetCLSIDForFileType(pidl, L"shellex\\IconHandler", &clsid);
1905 if (hr != S_OK)
1906 return hr;
1907
1908 hr = _CreateShellExtInstance(&clsid, pidl, riid, ppvOut);
1910 return S_FALSE;
1911
1912 return S_OK;
1913}
1914
1916{
1917 HRESULT hr;
1918 WCHAR wszPath[MAX_PATH], szNameBuf[MAX_PATH];
1919
1920 LPCWSTR pszName = GetItemFileName(pidl, szNameBuf, _countof(szNameBuf));
1921 if (!pszName)
1922 {
1923 ERR("Got garbage pidl\n");
1924 pdump_always(pidl);
1925 return E_INVALIDARG;
1926 }
1927 PathCombineW(wszPath, m_sPathTarget, pszName);
1928
1929 CComPtr<IPersistFile> pp;
1932 return hr;
1933
1934 pp->Load(wszPath, 0);
1935
1936 hr = pp->QueryInterface(riid, ppvOut);
1937 if (hr != S_OK)
1938 {
1939 ERR("Failed to query for interface IID_IShellExtInit hr %x pclsid %s\n", hr, wine_dbgstr_guid(pclsid));
1940 return hr;
1941 }
1942 return hr;
1943}
1944
1946{
1947 enum { IDC_PROPERTIES };
1948 /* no data object means no selection */
1949 if (!pdtobj)
1950 {
1951 if (uMsg == DFM_INVOKECOMMAND && wParam == IDC_PROPERTIES)
1952 {
1954 }
1955 else if (uMsg == DFM_MERGECONTEXTMENU)
1956 {
1957 QCMINFO *pqcminfo = (QCMINFO *)lParam;
1958 HMENU hpopup = CreatePopupMenu();
1960 pqcminfo->idCmdFirst = Shell_MergeMenus(pqcminfo->hmenu, hpopup, pqcminfo->indexMenu, pqcminfo->idCmdFirst, pqcminfo->idCmdLast, MM_ADDSEPARATOR);
1961 DestroyMenu(hpopup);
1962 return S_OK;
1963 }
1964 }
1965 return SHELL32_DefaultContextMenuCallBack(psf, pdtobj, uMsg);
1966}
1967
1969{
1970 // create stream from file
1971 HRESULT hr;
1972 CComPtr<IStream> pStream;
1974 FALSE, NULL, &pStream);
1975 if (FAILED(hr))
1976 return NULL;
1977
1978 // load the picture
1979 HBITMAP hbm = NULL;
1980 CComPtr<IPicture> pPicture;
1981 OleLoadPicture(pStream, 0, FALSE, IID_IPicture, (LPVOID *)&pPicture);
1982
1983 // get the bitmap handle
1984 if (pPicture)
1985 {
1986 pPicture->get_Handle((OLE_HANDLE *)&hbm);
1987
1988 // copy the bitmap handle
1990 }
1991
1992 return hbm;
1993}
1994
1996{
1997 if (data == NULL)
1998 {
1999 return E_POINTER;
2000 }
2001 if (data->cbSize != sizeof(*data))
2002 {
2003 // NOTE: You have to set the cbData member before SFVM_GET_CUSTOMVIEWINFO call.
2004 return E_INVALIDARG;
2005 }
2006
2007 data->hbmBack = NULL;
2008 data->clrText = CLR_INVALID;
2009 data->clrTextBack = CLR_INVALID;
2010
2012
2013 // does the folder exists?
2015 {
2016 return E_INVALIDARG;
2017 }
2018
2019 // don't use custom view in network path for security
2021 {
2022 return E_ACCESSDENIED;
2023 }
2024
2025 // build the ini file path
2027 PathAppend(szIniFile, L"desktop.ini");
2028
2029 static LPCWSTR TheGUID = L"{BE098140-A513-11D0-A3A4-00C04FD706EC}";
2030 static LPCWSTR Space = L" \t\n\r\f\v";
2031
2032 // get info from ini file
2033 WCHAR szImage[MAX_PATH], szText[64];
2034
2035 // load the image
2036 szImage[0] = UNICODE_NULL;
2037 GetPrivateProfileStringW(TheGUID, L"IconArea_Image", L"", szImage, _countof(szImage), szIniFile);
2038 if (szImage[0])
2039 {
2040 StrTrimW(szImage, Space);
2041 if (PathIsRelativeW(szImage))
2042 {
2043 PathAppendW(szPath, szImage);
2044 StringCchCopyW(szImage, _countof(szImage), szPath);
2045 }
2046 data->hbmBack = DoLoadPicture(szImage);
2047 }
2048
2049 // load the text color
2050 szText[0] = UNICODE_NULL;
2051 GetPrivateProfileStringW(TheGUID, L"IconArea_Text", L"", szText, _countof(szText), szIniFile);
2052 if (szText[0])
2053 {
2054 StrTrimW(szText, Space);
2055
2056 LPWSTR pchEnd = NULL;
2057 COLORREF cr = (wcstol(szText, &pchEnd, 0) & 0xFFFFFF);
2058
2059 if (pchEnd && !*pchEnd)
2060 data->clrText = cr;
2061 }
2062
2063 // load the text background color
2064 szText[0] = UNICODE_NULL;
2065 GetPrivateProfileStringW(TheGUID, L"IconArea_TextBackground", L"", szText, _countof(szText), szIniFile);
2066 if (szText[0])
2067 {
2068 StrTrimW(szText, Space);
2069
2070 LPWSTR pchEnd = NULL;
2071 COLORREF cr = (wcstol(szText, &pchEnd, 0) & 0xFFFFFF);
2072
2073 if (pchEnd && !*pchEnd)
2074 data->clrTextBack = cr;
2075 }
2076
2077 if (data->hbmBack != NULL || data->clrText != CLR_INVALID || data->clrTextBack != CLR_INVALID)
2078 return S_OK;
2079
2080 return E_FAIL;
2081}
2082
2084{
2086 switch (uMsg)
2087 {
2090 break;
2091 case SFVM_GETCOMMANDDIR:
2092 if (m_sPathTarget)
2094 break;
2095 }
2096 return hr;
2097}
2098
2100{
2101 FILETIME lft;
2103 FileTimeToLocalFileTime(&ft, &lft);
2104 FileTimeToSystemTime(&lft, &time);
2106 if (ret > 0 && ret < cchBuf)
2107 {
2108 /* Append space + time without seconds */
2109 Buf[ret-1] = ' ';
2111 }
2112 return ret ? S_OK : E_FAIL;
2113}
2114
2116{
2117 if (StrFormatKBSizeW(size, Buf, cchBuf))
2118 return S_OK;
2119 if (cchBuf)
2120 *Buf = UNICODE_NULL;
2121 return E_FAIL;
2122}
HRESULT WINAPI SHCreateShellFolderView(const SFV_CREATE *pcsfv, IShellView **ppsv)
Definition: CDefView.cpp:4677
HRESULT WINAPI SHCreateDefaultContextMenu(const DEFCONTEXTMENU *pdcm, REFIID riid, void **ppv)
HRESULT WINAPI SHCreateDefaultExtractIcon(REFIID riid, void **ppv)
HRESULT CFSDropTarget_CreateInstance(LPWSTR sPathTarget, REFIID riid, LPVOID *ppvOut)
HRESULT IDataObject_Constructor(HWND hwndOwner, PCIDLIST_ABSOLUTE pMyPidl, PCUIDLIST_RELATIVE_ARRAY apidl, UINT cidl, BOOL bExtendedObject, IDataObject **dataObject)
EXTERN_C HRESULT SHELL32_AssocGetFileDescription(PCWSTR Name, PWSTR Buf, UINT cchBuf)
EXTERN_C HRESULT SHELL32_AssocGetFSDirectoryDescription(PWSTR Buf, UINT cchBuf)
#define SFVM_GETCOMMANDDIR
#define SFVM_GET_CUSTOMVIEWINFO
unsigned long long UINT64
DWORD dwFileAttributes
UINT cchMax
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
void shell(int argc, const char *argv[])
Definition: cmds.c:1231
#define IDI_SHELL_FOLDER
Definition: treeview.c:21
#define FIXME(fmt,...)
Definition: precomp.h:53
#define WARN(fmt,...)
Definition: precomp.h:61
#define ERR(fmt,...)
Definition: precomp.h:57
#define IDS_PROPERTIES
Definition: resource.h:102
#define RegCloseKey(hKey)
Definition: registry.h:49
EXTERN_C void WINAPI SHChangeNotify(LONG wEventId, UINT uFlags, LPCVOID dwItem1, LPCVOID dwItem2)
BOOL AddToEnumList(LPITEMIDLIST pidl)
STDMETHOD() GetDisplayNameOf(PCUITEMID_CHILD pidl, DWORD dwFlags, LPSTRRET strRet) override
Definition: CFSFolder.cpp:1495
STDMETHOD() CallBack(IShellFolder *psf, HWND hwndOwner, IDataObject *pdtobj, UINT uMsg, WPARAM wParam, LPARAM lParam) override
Definition: CFSFolder.cpp:1945
STDMETHOD() Initialize(PCIDLIST_ABSOLUTE pidl) override
Definition: CFSFolder.cpp:1747
STDMETHOD() EnumObjects(HWND hwndOwner, DWORD dwFlags, LPENUMIDLIST *ppEnumIDList) override
Definition: CFSFolder.cpp:974
HRESULT _CreateShellExtInstance(const CLSID *pclsid, LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppvOut)
Definition: CFSFolder.cpp:1915
static HRESULT GetDefaultFSColumnState(UINT iColumn, SHCOLSTATEF &csFlags)
Definition: CFSFolder.cpp:590
STDMETHOD() SetNameOf(HWND hwndOwner, PCUITEMID_CHILD pidl, LPCOLESTR lpName, DWORD dwFlags, PITEMID_CHILD *pPidlOut) override
Definition: CFSFolder.cpp:1553
DWORD m_bGroupPolicyActive
Definition: CFSFolder.h:31
static HRESULT CompareSortFoldersFirst(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
Definition: CFSFolder.cpp:1091
static HRESULT FormatSize(UINT64 size, LPWSTR Buf, UINT cchBuf)
Definition: CFSFolder.cpp:2115
HRESULT _GetIconHandler(LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppvOut)
Definition: CFSFolder.cpp:1899
LPWSTR m_sPathTarget
Definition: CFSFolder.h:27
STDMETHOD() GetAttributesOf(UINT cidl, PCUITEMID_CHILD_ARRAY apidl, DWORD *rgfInOut) override
Definition: CFSFolder.cpp:1267
HRESULT _ParseSimple(_In_ LPOLESTR lpszDisplayName, _Inout_ WIN32_FIND_DATAW *pFind, _Out_ LPITEMIDLIST *ppidl)
Definition: CFSFolder.cpp:759
static HRESULT GetFSColumnDetails(UINT iColumn, SHELLDETAILS &sd)
Definition: CFSFolder.cpp:580
STDMETHOD() CompareIDs(LPARAM lParam, PCUIDLIST_RELATIVE pidl1, PCUIDLIST_RELATIVE pidl2) override
Definition: CFSFolder.cpp:1109
STDMETHOD() GetCurFolder(PIDLIST_ABSOLUTE *pidl) override
Definition: CFSFolder.cpp:1771
BOOL _GetFindDataFromName(_In_ LPCWSTR pszName, _Out_ WIN32_FIND_DATAW *pFind)
Definition: CFSFolder.cpp:800
STDMETHOD() GetUIObjectOf(HWND hwndOwner, UINT cidl, PCUITEMID_CHILD_ARRAY apidl, REFIID riid, UINT *prgfInOut, LPVOID *ppvOut) override
Definition: CFSFolder.cpp:1347
HRESULT _GetDropTarget(LPCITEMIDLIST pidl, LPVOID *ppvOut)
Definition: CFSFolder.cpp:1871
HRESULT _CreateIDListFromName(LPCWSTR pszName, DWORD attrs, IBindCtx *pbc, LPITEMIDLIST *ppidl)
Definition: CFSFolder.cpp:814
STDMETHOD() MapColumnToSCID(UINT column, SHCOLUMNID *pscid) override
Definition: CFSFolder.cpp:1719
const CLSID * m_pclsid
Definition: CFSFolder.h:24
STDMETHOD() BindToStorage(PCUIDLIST_RELATIVE pidl, LPBC pbcReserved, REFIID riid, LPVOID *ppvOut) override
Definition: CFSFolder.cpp:1078
STDMETHOD() ParseDisplayName(HWND hwndOwner, LPBC pbc, LPOLESTR lpszDisplayName, DWORD *pchEaten, PIDLIST_RELATIVE *ppidl, DWORD *pdwAttributes) override
Definition: CFSFolder.cpp:870
STDMETHOD() InitializeEx(IBindCtx *pbc, LPCITEMIDLIST pidlRoot, const PERSIST_FOLDER_TARGET_INFO *ppfti) override
Definition: CFSFolder.cpp:1787
STDMETHOD() GetDefaultColumnState(UINT iColumn, DWORD *pcsFlags) override
Definition: CFSFolder.cpp:1637
HRESULT WINAPI GetCustomViewInfo(ULONG unknown, SFVM_CUSTOMVIEWINFO_DATA *data)
Definition: CFSFolder.cpp:1995
STDMETHOD() MessageSFVCB(UINT uMsg, WPARAM wParam, LPARAM lParam) override
Definition: CFSFolder.cpp:2083
LPITEMIDLIST m_pidlRoot
Definition: CFSFolder.h:29
static HRESULT FormatDateTime(const FILETIME &ft, LPWSTR Buf, UINT cchBuf)
Definition: CFSFolder.cpp:2099
STDMETHOD() GetFolderTargetInfo(PERSIST_FOLDER_TARGET_INFO *ppfti) override
Definition: CFSFolder.cpp:1841
STDMETHOD() GetDetailsEx(PCUITEMID_CHILD pidl, const SHCOLUMNID *pscid, VARIANT *pv) override
Definition: CFSFolder.cpp:1648
STDMETHOD() EnumSearches(IEnumExtraSearch **ppenum) override
Definition: CFSFolder.cpp:1618
STDMETHOD() GetDefaultSearchGUID(GUID *pguid) override
Definition: CFSFolder.cpp:1612
STDMETHOD() GetClassID(CLSID *lpClassId) override
Definition: CFSFolder.cpp:1729
STDMETHOD() CreateViewObject(HWND hwndOwner, REFIID riid, LPVOID *ppvOut) override
Definition: CFSFolder.cpp:1172
STDMETHOD() GetDefaultColumn(DWORD dwRes, ULONG *pSort, ULONG *pDisplay) override
Definition: CFSFolder.cpp:1624
STDMETHOD() BindToObject(PCUIDLIST_RELATIVE pidl, LPBC pbcReserved, REFIID riid, LPVOID *ppvOut) override
Definition: CFSFolder.cpp:990
HRESULT _CreateExtensionUIObject(LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppvOut)
Definition: CFSFolder.cpp:1848
STDMETHOD() GetDetailsOf(PCUITEMID_CHILD pidl, UINT iColumn, SHELLDETAILS *psd) override
Definition: CFSFolder.cpp:1656
HRESULT _AddFindResult(LPWSTR sParentDir, const WIN32_FIND_DATAW &FindData, DWORD dwFlags)
Definition: CFSFolder.cpp:389
HRESULT WINAPI Initialize(LPWSTR sPathTarget, DWORD dwFlags)
Definition: CFSFolder.cpp:492
WPARAM wParam
Definition: combotst.c:138
LPARAM lParam
Definition: combotst.c:139
wcscat
#define CHARS_IN_GUID
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define E_INVALIDARG
Definition: ddrawi.h:101
#define E_NOTIMPL
Definition: ddrawi.h:99
#define E_FAIL
Definition: ddrawi.h:102
void pdump_always(LPCITEMIDLIST pidl)
Definition: debughlp.cpp:330
void pdump(LPCITEMIDLIST pidl)
Definition: debughlp.cpp:322
const char * shdebugstr_guid(const struct _GUID *id)
Definition: debughlp.cpp:438
#define ERROR_SUCCESS
Definition: deptool.c:10
static LSTATUS(WINAPI *pRegDeleteTreeW)(HKEY
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define SFGAO_SYSTEM
Definition: shobjidl.idl:198
#define IDS_SHV_COLUMN_TYPE
Definition: resource.h:75
#define IDS_SHV_COLUMN_NAME
Definition: resource.h:74
#define IDC_PROPERTIES
Definition: resource.h:32
#define GET_SHGDN_RELATION(dwFlags)
Definition: precomp.h:53
#define DFM_MERGECONTEXTMENU
Definition: precomp.h:44
#define DFM_INVOKECOMMAND
Definition: precomp.h:45
#define GET_SHGDN_FOR(dwFlags)
Definition: precomp.h:52
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3333
LSTATUS WINAPI RegGetValueW(HKEY hKey, LPCWSTR pszSubKey, LPCWSTR pszValue, DWORD dwFlags, LPDWORD pdwType, PVOID pvData, LPDWORD pcbData)
Definition: reg.c:1931
LONG WINAPI RegOpenKeyW(HKEY hKey, LPCWSTR lpSubKey, PHKEY phkResult)
Definition: reg.c:3268
LSTATUS WINAPI RegQueryValueW(HKEY hkey, LPCWSTR name, LPWSTR data, LPLONG count)
Definition: reg.c:4241
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4103
UINT uFlags
Definition: api.c:59
BOOL WINAPI _ILIsPidlSimple(LPCITEMIDLIST pidl)
static WCHAR unknown[MAX_STRING_RESOURCE_LEN]
Definition: object.c:1605
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
#define MAX_PATH
Definition: compat.h:34
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:137
#define lstrcpynW
Definition: compat.h:738
#define lstrlenW
Definition: compat.h:750
static const WCHAR *const ext[]
Definition: module.c:53
#define FAILED_UNEXPECTEDLY(hr)
Definition: precomp.h:121
DWORD WINAPI ExpandEnvironmentStringsW(IN LPCWSTR lpSrc, IN LPWSTR lpDst, IN DWORD nSize)
Definition: environ.c:519
HANDLE WINAPI FindFirstFileW(IN LPCWSTR lpFileName, OUT LPWIN32_FIND_DATAW lpFindFileData)
Definition: find.c:320
BOOL WINAPI FindClose(HANDLE hFindFile)
Definition: find.c:502
BOOL WINAPI FindNextFileW(IN HANDLE hFindFile, OUT LPWIN32_FIND_DATAW lpFindFileData)
Definition: find.c:382
BOOL WINAPI MoveFileW(IN LPCWSTR lpExistingFileName, IN LPCWSTR lpNewFileName)
Definition: move.c:1104
DWORD WINAPI GetFullPathNameW(IN LPCWSTR lpFileName, IN DWORD nBufferLength, OUT LPWSTR lpBuffer, OUT LPWSTR *lpFilePart)
Definition: path.c:1106
BOOL WINAPI FileTimeToSystemTime(IN CONST FILETIME *lpFileTime, OUT LPSYSTEMTIME lpSystemTime)
Definition: time.c:188
BOOL WINAPI FileTimeToLocalFileTime(IN CONST FILETIME *lpFileTime, OUT LPFILETIME lpLocalFileTime)
Definition: time.c:221
UINT WINAPI GetPrivateProfileIntW(LPCWSTR section, LPCWSTR entry, INT def_val, LPCWSTR filename)
Definition: profile.c:1297
INT WINAPI GetPrivateProfileStringW(LPCWSTR section, LPCWSTR entry, LPCWSTR def_val, LPWSTR buffer, UINT len, LPCWSTR filename)
Definition: profile.c:1142
int WINAPI lstrcmpiW(LPCWSTR str1, LPCWSTR str2)
Definition: locale.c:4262
HRESULT WINAPI CLSIDFromString(LPCOLESTR idstr, LPCLSID id)
Definition: compobj.c:2338
HRESULT WINAPI OleLoadPicture(LPSTREAM lpstream, LONG lSize, BOOL fRunmode, REFIID riid, LPVOID *ppvObj)
Definition: olepicture.c:2344
#define RRF_RT_REG_DWORD
Definition: driver.c:578
#define RRF_RT_REG_SZ
Definition: driver.c:575
BOOL SHELL_FS_HideExtension(LPCWSTR szPath)
Definition: CFSFolder.cpp:1438
static HRESULT SHELL32_GetCLSIDForDirectory(LPCWSTR pwszDir, LPCWSTR KeyName, CLSID *pclsidFolder)
Definition: CFSFolder.cpp:599
#define GENERICSHELLVIEWCOLUMNS
Definition: CFSFolder.cpp:578
static LPCWSTR ExtensionFromPidl(PCUIDLIST_RELATIVE pidl, LPWSTR Buf, UINT cchMax)
Definition: CFSFolder.cpp:91
static BOOL getShellClassInfo(LPCWSTR Entry, LPWSTR pszValue, DWORD cchValueLen, LPCWSTR IniFile)
Definition: CFSFolder.cpp:199
static void GetItemDescription(PCUITEMID_CHILD pidl, LPWSTR Buf, UINT cchMax)
Definition: CFSFolder.cpp:44
#define SUPER_HIDDEN
static HRESULT getIconLocationForFolder(IShellFolder *psf, PCITEMID_CHILD pidl, UINT uFlags, LPWSTR szIconFile, UINT cchMax, int *piIndex, UINT *pwFlags)
Definition: CFSFolder.cpp:205
HRESULT SHELL32_GetFSItemAttributes(IShellFolder *psf, LPCITEMIDLIST pidl, LPDWORD pdwAttributes)
Definition: CFSFolder.cpp:619
static HRESULT getDefaultIconLocation(LPWSTR szIconFile, UINT cchMax, int *piIndex, UINT uFlags)
Definition: CFSFolder.cpp:175
static const shvheader GenericSFHeader[]
Definition: CFSFolder.cpp:569
HRESULT GetCLSIDForFileType(PCUIDLIST_RELATIVE pidl, LPCWSTR KeyName, CLSID *pclsid)
Definition: CFSFolder.cpp:164
static LPCWSTR GetItemFileName(PCUITEMID_CHILD pidl, LPWSTR Buf, UINT cchMax)
Definition: CFSFolder.cpp:24
static HRESULT GetCLSIDForFileTypeFromExtension(LPCWSTR pExtension, LPCWSTR KeyName, CLSID *pclsid)
Definition: CFSFolder.cpp:109
static HKEY OpenKeyFromFileType(LPCWSTR pExtension, LPCWSTR KeyName)
Definition: CFSFolder.cpp:61
void SHELL_FS_ProcessDisplayFilename(LPWSTR szPath, DWORD dwFlags)
Definition: CFSFolder.cpp:1472
HRESULT CFSExtractIcon_CreateInstance(IShellFolder *psf, LPCITEMIDLIST pidl, REFIID iid, LPVOID *ppvOut)
Definition: CFSFolder.cpp:281
static BOOL ItemIsFolder(PCUITEMID_CHILD pidl)
Definition: CFSFolder.cpp:17
static BOOL IsRealItem(const ITEMIDLIST &idl)
Definition: CFSFolder.cpp:37
static HBITMAP DoLoadPicture(LPCWSTR pszFileName)
Definition: CFSFolder.cpp:1968
DWORD BindCtx_GetMode(_In_ IBindCtx *pbc, _In_ DWORD dwDefault)
Definition: utils.cpp:278
HRESULT SHIsFileSysBindCtx(_In_ IBindCtx *pBindCtx, _Out_opt_ WIN32_FIND_DATAW *pFindData)
Definition: utils.cpp:303
HRESULT SHELL32_DefaultContextMenuCallBack(IShellFolder *psf, IDataObject *pdo, UINT msg)
Definition: shlfolder.cpp:525
HRESULT SHILAppend(_Inout_ LPITEMIDLIST pidl, _Inout_ LPITEMIDLIST *ppidl)
Definition: utils.cpp:193
BOOL PathIsDosDevice(_In_ LPCWSTR pszName)
Definition: utils.cpp:172
HRESULT SHILClone(_In_opt_ LPCITEMIDLIST pidl, _Outptr_ LPITEMIDLIST *ppidl)
Definition: utils.cpp:133
void WINAPI SHFree(LPVOID pv)
Definition: shellole.c:326
HRESULT WINAPI SHCoCreateInstance(LPCWSTR aclsid, const CLSID *clsid, LPUNKNOWN pUnkOuter, REFIID refiid, LPVOID *ppv)
Definition: shellole.c:105
BOOL WINAPI SHGetSpecialFolderPathW(HWND hwndOwner, LPWSTR szPath, int nFolder, BOOL bCreate)
Definition: shellpath.c:3092
HRESULT WINAPI SHCreateStreamOnFileEx(LPCWSTR lpszPath, DWORD dwMode, DWORD dwAttributes, BOOL bCreate, IStream *lpTemplate, IStream **lppStream)
Definition: istream.c:401
LPWSTR WINAPI PathFindFileNameW(LPCWSTR lpszPath)
Definition: path.c:394
LPWSTR WINAPI PathFindExtensionW(LPCWSTR lpszPath)
Definition: path.c:447
void WINAPI PathRemoveExtensionW(LPWSTR lpszPath)
Definition: path.c:823
BOOL WINAPI PathFileExistsW(LPCWSTR lpszPath)
Definition: path.c:1783
VOID WINAPI PathUnquoteSpacesW(LPWSTR lpszPath)
Definition: path.c:1040
BOOL WINAPI PathIsDirectoryW(LPCWSTR lpszPath)
Definition: path.c:1729
int WINAPI PathParseIconLocationW(LPWSTR lpszPath)
Definition: path.c:1098
BOOL WINAPI PathIsRelativeW(LPCWSTR lpszPath)
Definition: path.c:1585
HRESULT WINAPI SHRegGetCLSIDKeyW(REFGUID, LPCWSTR, BOOL, BOOL, PHKEY)
Definition: reg.c:2422
DWORD WINAPI SHQueryValueExW(HKEY hKey, LPCWSTR lpszValue, LPDWORD lpReserved, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData)
Definition: reg.c:1461
HRESULT WINAPI SHStrDupW(LPCWSTR src, LPWSTR *dest)
Definition: string.c:2018
LPWSTR WINAPI StrFormatKBSizeW(LONGLONG llBytes, LPWSTR lpszDest, UINT cchMax)
Definition: string.c:1757
BOOL WINAPI StrTrimW(LPWSTR lpszStr, LPCWSTR lpszTrim)
Definition: string.c:1883
HRESULT WINAPI StrRetToStrW(LPSTRRET lpStrRet, const ITEMIDLIST *pidl, LPWSTR *ppszName)
Definition: string.c:1631
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
WCHAR swShell32Name[MAX_PATH]
Definition: folders.cpp:22
FxAutoRegKey hKey
Status
Definition: gdiplustypes.h:25
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLuint res
Definition: glext.h:9613
GLsizeiptr size
Definition: glext.h:5919
GLenum GLint GLuint mask
Definition: glext.h:6028
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLbitfield flags
Definition: glext.h:7161
GLuint64EXT * result
Definition: glext.h:11304
GLenum GLsizei len
Definition: glext.h:6722
LPVOID WINAPI CoTaskMemAlloc(SIZE_T size)
Definition: ifs.c:426
_Check_return_ long __cdecl wcstol(_In_z_ const wchar_t *_Str, _Out_opt_ _Deref_post_z_ wchar_t **_EndPtr, _In_ int _Radix)
_Check_return_ _CRTIMP int __cdecl _wtoi(_In_z_ const wchar_t *_Str)
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
REFIID riid
Definition: atlbase.h:39
ULONG SFGAOF
Definition: shobjidl.idl:222
HRESULT BindToObject([in] PCUIDLIST_RELATIVE pidl, [in] LPBC pbcReserved, [in] REFIID riid, [out, iid_is(riid)] void **ppvOut)
HRESULT GetDisplayNameOf([in] PCUITEMID_CHILD pidl, [in] SHGDNF uFlags, [out] STRRET *lpName)
HRESULT GetAttributesOf([in] UINT cidl, [in, size_is(cidl)] PCUITEMID_CHILD_ARRAY apidl, [in, out] SFGAOF *rgfInOut)
HRESULT QueryInterface([in] REFIID riid, [out, iid_is(riid)] void **ppvObject)
ULONG Release()
#define S_OK
Definition: intsafe.h:52
#define SUCCEEDED(hr)
Definition: intsafe.h:50
#define ULONG_MAX
Definition: intsafe.h:155
#define FAILED(hr)
Definition: intsafe.h:51
HRESULT SHELL_ShowItemIDListProperties(LPCITEMIDLIST pidl)
Definition: item_prop.cpp:182
#define debugstr_w
Definition: kernel32.h:32
INT WINAPI GetTimeFormatW(LCID lcid, DWORD dwFlags, const SYSTEMTIME *lpTime, LPCWSTR lpFormat, LPWSTR lpTimeStr, INT cchOut)
Definition: lcformat.c:1093
INT WINAPI GetDateFormatW(LCID lcid, DWORD dwFlags, const SYSTEMTIME *lpTime, LPCWSTR lpFormat, LPWSTR lpDateStr, INT cchOut)
Definition: lcformat.c:993
#define BEGIN_COM_MAP(x)
Definition: atlcom.h:581
#define COM_INTERFACE_ENTRY_IID(iid, x)
Definition: atlcom.h:601
#define END_COM_MAP()
Definition: atlcom.h:592
__u16 time
Definition: mkdosfs.c:8
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
LPCWSTR szPath
Definition: env.c:37
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
static HBITMAP
Definition: button.c:44
HRESULT hres
Definition: protocol.c:465
static const struct access_res create[16]
Definition: package.c:7505
static const WCHAR sd[]
Definition: suminfo.c:286
static IParseDisplayName ParseDisplayName
Definition: moniker.c:816
static LPOLESTR
Definition: stg_prop.c:27
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HMENU
Definition: ordinal.c:63
static SHCONTF
Definition: ordinal.c:64
static PROTOCOLDATA * pdata
Definition: protocol.c:158
REFCLSID clsid
Definition: msctf.c:82
unsigned int UINT
Definition: ndis.h:50
#define _Inout_
Definition: no_sal2.h:162
#define _Out_
Definition: no_sal2.h:160
#define _In_
Definition: no_sal2.h:158
#define FILE_ATTRIBUTE_READONLY
Definition: nt_native.h:702
#define FILE_ATTRIBUTE_COMPRESSED
Definition: nt_native.h:711
#define KEY_READ
Definition: nt_native.h:1023
#define FILE_ATTRIBUTE_HIDDEN
Definition: nt_native.h:703
#define FILE_ATTRIBUTE_SYSTEM
Definition: nt_native.h:704
#define FILE_ATTRIBUTE_DIRECTORY
Definition: nt_native.h:705
#define LOCALE_USER_DEFAULT
#define DEFAULT_UNREACHABLE
#define UNICODE_NULL
_In_ HBITMAP hbm
Definition: ntgdi.h:2776
#define FILE_ATTRIBUTE_ENCRYPTED
Definition: ntifs_ex.h:385
#define L(x)
Definition: ntvdm.h:50
#define STGM_CREATE
Definition: objbase.h:926
#define STGM_READ
Definition: objbase.h:917
interface IBindCtx * LPBC
Definition: objfwd.h:18
const GUID IID_IPicture
const GUID IID_IDataObject
#define PathAddExtensionW
Definition: pathcch.h:305
#define PathCombineW
Definition: pathcch.h:317
#define PathAddBackslashW
Definition: pathcch.h:301
#define PathAppendW
Definition: pathcch.h:309
#define LOWORD(l)
Definition: pedump.c:82
long LONG
Definition: pedump.c:60
LPITEMIDLIST WINAPI ILClone(LPCITEMIDLIST pidl)
Definition: pidl.c:237
void WINAPI ILFree(LPITEMIDLIST pidl)
Definition: pidl.c:1044
DWORD _ILGetFileAttributes(LPCITEMIDLIST pidl, LPWSTR pOut, UINT uOutSize)
Definition: pidl.c:2563
LPITEMIDLIST WINAPI ILFindLastID(LPCITEMIDLIST pidl)
Definition: pidl.c:198
LPPIDLDATA _ILGetDataPointer(LPCITEMIDLIST pidl)
Definition: pidl.c:2254
HRESULT WINAPI SHBindToParent(LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppv, LPCITEMIDLIST *ppidlLast)
Definition: pidl.c:1462
FileStructW * _ILGetFileStructW(LPCITEMIDLIST pidl)
Definition: pidl.c:2428
BOOL _ILIsFolder(LPCITEMIDLIST pidl)
Definition: pidl.c:2120
BOOL WINAPI SHGetPathFromIDListW(LPCITEMIDLIST pidl, LPWSTR pszPath)
Definition: pidl.c:1454
LPITEMIDLIST WINAPI ILGetNext(LPCITEMIDLIST pidl)
Definition: pidl.c:970
BOOL ILGetDisplayNameExW(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, LPWSTR path, DWORD type)
Definition: pidl.c:100
BOOL _ILGetFileDateTime(LPCITEMIDLIST pidl, FILETIME *pFt)
Definition: pidl.c:2470
DWORD _ILGetFileSize(LPCITEMIDLIST pidl, LPWSTR pOut, UINT uOutSize)
Definition: pidl.c:2497
BOOL _ILIsValue(LPCITEMIDLIST pidl)
Definition: pidl.c:2127
BOOL _ILIsDrive(LPCITEMIDLIST pidl)
Definition: pidl.c:2113
BOOL _ILGetExtension(LPCITEMIDLIST pidl, LPWSTR pOut, UINT uOutSize)
Definition: pidl.c:2516
DWORD _ILSimpleGetTextW(LPCITEMIDLIST pidl, LPWSTR szOut, UINT uOutSize)
Definition: pidl.c:2174
LPITEMIDLIST _ILCreateFromFindDataW(const WIN32_FIND_DATAW *wfd)
Definition: pidl.c:1894
static BYTE _ILGetType(LPCITEMIDLIST pidl)
Definition: pidl.h:120
static BYTE _ILGetFSType(LPCITEMIDLIST pidl)
Definition: pidl.h:125
#define LVCFMT_LEFT
Definition: commctrl.h:2603
#define LVCFMT_RIGHT
Definition: commctrl.h:2604
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
#define REFIID
Definition: guiddef.h:118
#define strcmpW(s1, s2)
Definition: unicode.h:44
#define sprintfW
Definition: unicode.h:64
WCHAR classname[128]
Definition: startup.c:15
static calc_node_t temp
Definition: rpn_ieee.c:38
TCHAR szIniFile[]
Definition: scrnsave.c:29
_Check_return_ _CRTIMP int __cdecl _wcsicmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
_Check_return_ _CRTIMP int __cdecl wcscmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
static __inline const char * wine_dbgstr_guid(const GUID *id)
Definition: debug.h:197
BOOL HCR_GetIconW(LPCWSTR szClass, LPWSTR szDest, LPCWSTR szName, DWORD len, int *picon_idx)
Definition: classes.c:314
#define __SHFreeAndNil(ptr)
Definition: shell32_main.h:154
DWORD WINAPI ParseFieldW(LPCWSTR src, DWORD nField, LPWSTR dst, DWORD len) DECLSPEC_HIDDEN
Definition: shellord.c:117
#define CSIDL_FLAG_CREATE
#define STATUS_SUCCESS
Definition: shellext.h:65
HRESULT HResultFromWin32(DWORD hr)
Definition: shellutils.h:70
#define MAKE_COMPARE_HRESULT(x)
Definition: shellutils.h:619
#define SHELL_GetSetting(pss, ssf, field)
Definition: shellutils.h:826
#define S_EQUAL
Definition: shellutils.h:617
HRESULT SHELL32_BindToSF(LPCITEMIDLIST pidlRoot, PERSIST_FOLDER_TARGET_INFO *ppfti, LPCITEMIDLIST pidl, const GUID *clsid, REFIID riid, LPVOID *ppvOut)
Definition: shlfolder.cpp:196
#define SHFSF_COL_COMMENT
Definition: shfldr.h:48
#define SHFSF_COL_SIZE
Definition: shfldr.h:44
HRESULT SHELL32_GetDisplayNameOfChild(IShellFolder2 *psf, LPCITEMIDLIST pidl, DWORD dwFlags, LPSTRRET strRet)
Definition: shlfolder.cpp:234
SHCONTF SHELL_GetDefaultFolderEnumSHCONTF()
Definition: shlfolder.cpp:29
#define SHFSF_COL_NAME
Definition: shfldr.h:43
HRESULT SHELL32_CompareChildren(IShellFolder2 *psf, LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
Definition: shlfolder.cpp:252
void AddFSClassKeysToArray(UINT cidl, PCUITEMID_CHILD_ARRAY apidl, HKEY *array, UINT *cKeys)
Definition: shlfolder.cpp:333
#define SHFSF_COL_TYPE
Definition: shfldr.h:45
LSTATUS AddClassKeyToArray(const WCHAR *szClass, HKEY *array, UINT *cKeys)
Definition: shlfolder.cpp:311
HRESULT SHELL32_CompareDetails(IShellFolder2 *isf, LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
Definition: shlfolder.cpp:275
#define SHFSF_COL_FATTS
Definition: shfldr.h:47
HRESULT Shell_NextElement(_Inout_ LPWSTR *ppch, _Out_ LPWSTR pszOut, _In_ INT cchOut, _In_ BOOL bValidate)
Definition: shlfolder.cpp:58
#define SHFSF_COL_MDATE
Definition: shfldr.h:46
void WINAPI _InsertMenuItemW(HMENU hmenu, UINT indexMenu, BOOL fByPosition, UINT wID, UINT fType, LPCWSTR dwTypeData, UINT fState)
HRESULT hr
Definition: shlfolder.c:183
UINT WINAPI Shell_MergeMenus(HMENU hmDst, HMENU hmSrc, UINT uInsert, UINT uIDAdjust, UINT uIDAdjustMax, ULONG uFlags)
Definition: shlmenu.c:856
#define SHCNE_RENAMEITEM
Definition: shlobj.h:1890
#define SHCNE_RENAMEFOLDER
Definition: shlobj.h:1907
#define SSF_SHOWEXTENSIONS
Definition: shlobj.h:1606
#define SHCNF_PATHW
Definition: shlobj.h:1925
#define MM_ADDSEPARATOR
Definition: shlobj.h:2528
struct _SFV_CREATE SFV_CREATE
LSTATUS WINAPI SHRegGetValueW(_In_ HKEY hkey, _In_opt_ LPCWSTR pszSubKey, _In_opt_ LPCWSTR pszValue, _In_ SRRF srrfFlags, _Out_opt_ LPDWORD pdwType, _Out_writes_bytes_to_opt_(*pcbData, *pcbData) LPVOID pvData, _Inout_opt_ LPDWORD pcbData)
#define PathIsNetworkPath
Definition: shlwapi.h:1127
#define PathAppend
Definition: shlwapi.h:827
#define IDI_SHELL_EXE
Definition: shresdef.h:555
#define IDS_SHV_COLUMN_SIZE
Definition: shresdef.h:50
#define IDS_SHV_COLUMN_MODIFIED
Definition: shresdef.h:52
#define IDI_SHELL_DOCUMENT
Definition: shresdef.h:553
#define IDS_SHV_COLUMN_COMMENTS
Definition: shresdef.h:67
#define IDS_SHV_COLUMN_ATTRIBUTES
Definition: shresdef.h:53
ITEMIDLIST UNALIGNED * LPITEMIDLIST
Definition: shtypes.idl:41
@ STRRET_CSTR
Definition: shtypes.idl:87
@ STRRET_WSTR
Definition: shtypes.idl:85
const PCUITEMID_CHILD * PCUITEMID_CHILD_ARRAY
Definition: shtypes.idl:71
const ITEMID_CHILD UNALIGNED * PCUITEMID_CHILD
Definition: shtypes.idl:70
@ SHCOLSTATE_TYPE_INT
Definition: shtypes.idl:122
@ SHCOLSTATE_TYPE_DATE
Definition: shtypes.idl:123
@ SHCOLSTATE_TYPE_STR
Definition: shtypes.idl:121
@ SHCOLSTATE_SLOW
Definition: shtypes.idl:126
@ SHCOLSTATE_ONBYDEFAULT
Definition: shtypes.idl:125
const ITEMIDLIST_RELATIVE UNALIGNED * PCUIDLIST_RELATIVE
Definition: shtypes.idl:57
const ITEMIDLIST UNALIGNED * LPCITEMIDLIST
Definition: shtypes.idl:42
DWORD SHCOLSTATEF
Definition: shtypes.idl:142
#define _countof(array)
Definition: sndvol32.h:70
#define TRACE(s)
Definition: solgame.cpp:4
STRSAFEAPI StringCchCatW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszSrc)
Definition: strsafe.h:325
STRSAFEAPI StringCbCopyW(STRSAFE_LPWSTR pszDest, size_t cbDest, STRSAFE_LPCWSTR pszSrc)
Definition: strsafe.h:166
STRSAFEAPI StringCchCopyW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszSrc)
Definition: strsafe.h:149
IContextMenuCB * pcmcb
Definition: shlobj.h:2550
IShellFolder * psf
Definition: shlobj.h:2552
IUnknown * punkAssociationInfo
Definition: shlobj.h:2555
PCUITEMID_CHILD_ARRAY apidl
Definition: shlobj.h:2554
const HKEY * aKeys
Definition: shlobj.h:2557
PCIDLIST_ABSOLUTE pidlFolder
Definition: shlobj.h:2551
base of all file and directory entries
Definition: entries.h:83
WCHAR wszName[1]
Definition: shlfolder.c:1555
STRRET str
Definition: shtypes.idl:108
BYTE abID[1]
Definition: shtypes.idl:28
SHITEMID mkid
Definition: shtypes.idl:34
HMENU hmenu
Definition: shlobj.h:1390
UINT idCmdLast
Definition: shlobj.h:1393
UINT idCmdFirst
Definition: shlobj.h:1392
UINT indexMenu
Definition: shlobj.h:1391
char cStr[MAX_PATH]
Definition: shtypes.idl:98
UINT uType
Definition: shtypes.idl:93
LPWSTR pOleStr
Definition: shtypes.idl:96
Definition: name.c:39
WORD colstate
Definition: shfldr.h:31
WORD uFileDate
Definition: pidl.h:178
DWORD dwFileSize
Definition: pidl.h:177
union tagPIDLDATA::@563 u
struct tagFileStruct file
Definition: pidl.h:211
TW_UINT32 TW_UINT16 TW_UINT16 TW_MEMREF pData
Definition: twain.h:1830
uint16_t * PWSTR
Definition: typedefs.h:56
uint32_t * LPDWORD
Definition: typedefs.h:59
int32_t INT
Definition: typedefs.h:58
uint32_t ULONG
Definition: typedefs.h:59
#define ILGDN_FORPARSING
Definition: undocshell.h:71
DWORD dwAttributes
Definition: vdmdbg.h:34
WORD WORD PSZ PSZ pszFileName
Definition: vdmdbg.h:44
int ret
_Must_inspect_result_ _In_ WDFDEVICE _In_ PCUNICODE_STRING KeyName
Definition: wdfdevice.h:2699
#define ZeroMemory
Definition: winbase.h:1737
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
_In_ LPCSTR lpName
Definition: winbase.h:2814
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176
LONG_PTR LPARAM
Definition: windef.h:208
UINT_PTR WPARAM
Definition: windef.h:207
DWORD COLORREF
Definition: windef.h:300
#define WINAPI
Definition: msvc.h:6
#define S_FALSE
Definition: winerror.h:2357
#define E_NOINTERFACE
Definition: winerror.h:2364
#define ERROR_PATH_NOT_FOUND
Definition: winerror.h:106
#define FACILITY_SHELL
Definition: winerror.h:56
#define E_ACCESSDENIED
Definition: winerror.h:2849
#define SEVERITY_ERROR
Definition: winerror.h:65
#define ERROR_NO_MORE_FILES
Definition: winerror.h:121
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92
#define E_POINTER
Definition: winerror.h:2365
#define MAKE_SCODE(sev, fac, code)
Definition: winerror.h:70
#define ERROR_BAD_DEVICE
Definition: winerror.h:703
#define CLR_INVALID
Definition: wingdi.h:883
#define TIME_NOSECONDS
Definition: winnls.h:280
#define DATE_SHORTDATE
Definition: winnls.h:198
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
#define HKEY_CLASSES_ROOT
Definition: winreg.h:10
HMENU WINAPI CreatePopupMenu(void)
Definition: menu.c:838
#define IMAGE_BITMAP
Definition: winuser.h:211
UINT WINAPI PrivateExtractIconsW(_In_reads_(MAX_PATH) LPCWSTR szFileName, _In_ int nIconIndex, _In_ int cxIcon, _In_ int cyIcon, _Out_writes_opt_(nIcons) HICON *phicon, _Out_writes_opt_(nIcons) UINT *piconid, _In_ UINT nIcons, _In_ UINT flags)
#define LR_CREATEDIBSECTION
Definition: winuser.h:1101
HANDLE WINAPI CopyImage(_In_ HANDLE, _In_ UINT, _In_ int, _In_ int, _In_ UINT)
Definition: cursoricon.c:2024
#define wsprintf
Definition: winuser.h:5877
#define MFS_ENABLED
Definition: winuser.h:753
BOOL WINAPI DestroyMenu(_In_ HMENU)
#define MFT_STRING
Definition: winuser.h:749
#define MAKEINTRESOURCEW(i)
Definition: winuser.h:582
_In_ PSTRING FullName
Definition: rtlfuncs.h:1665
#define IID_PPV_ARG(Itype, ppType)
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
unsigned char BYTE
Definition: xxhash.c:193