ReactOS 0.4.16-dev-1172-g2041f3c
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;
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 (!AllowFolder && !_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
175{
176 WCHAR buf[256];
177 LPCWSTR pExt = ExtensionFromPidl(pidl, buf, _countof(buf), TRUE);
178 if (!pExt)
179 return E_FAIL;
180 HRESULT hr = E_FAIL;
181 if (!ItemIsFolder(pidl))
182 hr = GetCLSIDForFileTypeFromExtension(pExt, L"CLSID", pclsid);
183 // TODO: Should we handle folders with desktop.ini here?
184 if (hr != S_OK && pExt[0] == '.' && pExt[1] == '{')
185 hr = CLSIDFromString(pExt + 1, pclsid);
186 return hr;
187}
188
189static HRESULT
191{
192 if (!HLM_GetIconW(IDI_SHELL_FOLDER - 1, szIconFile, cchMax, piIndex))
193 {
194 if (!HCR_GetIconW(L"Folder", szIconFile, NULL, cchMax, piIndex))
195 {
196 StringCchCopyW(szIconFile, cchMax, swShell32Name);
197 *piIndex = -IDI_SHELL_FOLDER;
198 }
199 }
200
201 if (uFlags & GIL_OPENICON)
202 {
203 // next icon
204 if (*piIndex < 0)
205 (*piIndex)--;
206 else
207 (*piIndex)++;
208 }
209
210 return S_OK;
211}
212
213static BOOL
214getShellClassInfo(LPCWSTR Entry, LPWSTR pszValue, DWORD cchValueLen, LPCWSTR IniFile)
215{
216 return GetPrivateProfileStringW(L".ShellClassInfo", Entry, NULL, pszValue, cchValueLen, IniFile);
217}
218
219static HRESULT
221 LPWSTR szIconFile, UINT cchMax, int *piIndex, UINT *pwFlags)
222{
223 DWORD dwFileAttrs;
224 WCHAR wszPath[MAX_PATH];
225 WCHAR wszIniFullPath[MAX_PATH];
226
227 if (uFlags & GIL_DEFAULTICON)
228 goto Quit;
229
230 // get path
231 if (!ILGetDisplayNameExW(psf, pidl, wszPath, 0))
232 goto Quit;
233 if (!PathIsDirectoryW(wszPath))
234 goto Quit;
235
236 // read-only or system folder?
237 dwFileAttrs = _ILGetFileAttributes(ILFindLastID(pidl), NULL, 0);
238 if ((dwFileAttrs & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)) == 0)
239 goto Quit;
240
241 // build the full path of ini file
242 StringCchCopyW(wszIniFullPath, _countof(wszIniFullPath), wszPath);
243 PathAppendW(wszIniFullPath, L"desktop.ini");
244
245 WCHAR wszValue[MAX_PATH], wszTemp[MAX_PATH];
246 if (getShellClassInfo(L"IconFile", wszValue, _countof(wszValue), wszIniFullPath))
247 {
248 // wszValue --> wszTemp
249 ExpandEnvironmentStringsW(wszValue, wszTemp, _countof(wszTemp));
250
251 // wszPath + wszTemp --> wszPath
252 if (PathIsRelativeW(wszTemp))
253 PathAppendW(wszPath, wszTemp);
254 else
255 StringCchCopyW(wszPath, _countof(wszPath), wszTemp);
256
257 // wszPath --> szIconFile
258 GetFullPathNameW(wszPath, cchMax, szIconFile, NULL);
259
260 *piIndex = GetPrivateProfileIntW(L".ShellClassInfo", L"IconIndex", 0, wszIniFullPath);
261 return S_OK;
262 }
263 else if (getShellClassInfo(L"CLSID", wszValue, _countof(wszValue), wszIniFullPath) &&
264 HCR_GetIconW(wszValue, szIconFile, NULL, cchMax, piIndex))
265 {
266 return S_OK;
267 }
268 else if (getShellClassInfo(L"CLSID2", wszValue, _countof(wszValue), wszIniFullPath) &&
269 HCR_GetIconW(wszValue, szIconFile, NULL, cchMax, piIndex))
270 {
271 return S_OK;
272 }
273 else if (getShellClassInfo(L"IconResource", wszValue, _countof(wszValue), wszIniFullPath))
274 {
275 // wszValue --> wszTemp
276 ExpandEnvironmentStringsW(wszValue, wszTemp, _countof(wszTemp));
277
278 // parse the icon location
279 *piIndex = PathParseIconLocationW(wszTemp);
280
281 // wszPath + wszTemp --> wszPath
282 if (PathIsRelativeW(wszTemp))
283 PathAppendW(wszPath, wszTemp);
284 else
285 StringCchCopyW(wszPath, _countof(wszPath), wszTemp);
286
287 // wszPath --> szIconFile
288 GetFullPathNameW(wszPath, cchMax, szIconFile, NULL);
289 return S_OK;
290 }
291
292Quit:
293 return getDefaultIconLocation(szIconFile, cchMax, piIndex, uFlags);
294}
295
297{
298 CComPtr<IDefaultExtractIconInit> initIcon;
299 HRESULT hr;
300 int icon_idx = 0;
301 UINT flags = 0; // FIXME: Use it!
302 WCHAR wTemp[MAX_PATH] = L"";
303
305 if (FAILED(hr))
306 return hr;
307
308 if (_ILIsFolder (pidl))
309 {
311 pidl, 0, wTemp, _countof(wTemp),
312 &icon_idx,
313 &flags)))
314 {
315 initIcon->SetNormalIcon(wTemp, icon_idx);
316 // FIXME: if/when getIconLocationForFolder does something for
317 // GIL_FORSHORTCUT, code below should be uncommented. and
318 // the following line removed.
319 initIcon->SetShortcutIcon(wTemp, icon_idx);
320 }
322 pidl, GIL_DEFAULTICON, wTemp, _countof(wTemp),
323 &icon_idx,
324 &flags)))
325 {
326 initIcon->SetDefaultIcon(wTemp, icon_idx);
327 }
328 // if (SUCCEEDED(getIconLocationForFolder(psf,
329 // pidl, GIL_FORSHORTCUT, wTemp, _countof(wTemp),
330 // &icon_idx,
331 // &flags)))
332 // {
333 // initIcon->SetShortcutIcon(wTemp, icon_idx);
334 // }
336 pidl, GIL_OPENICON, wTemp, _countof(wTemp),
337 &icon_idx,
338 &flags)))
339 {
340 initIcon->SetOpenIcon(wTemp, icon_idx);
341 }
342 }
343 else
344 {
345 WCHAR extbuf[256];
346 LPCWSTR pExtension = ExtensionFromPidl(pidl, extbuf, _countof(extbuf));
347 HKEY hkey = pExtension ? OpenKeyFromFileType(pExtension, L"DefaultIcon") : NULL;
348 if (!hkey)
349 WARN("Could not open DefaultIcon key!\n");
350
351 DWORD dwSize = sizeof(wTemp);
352 if (hkey && !SHQueryValueExW(hkey, NULL, NULL, NULL, wTemp, &dwSize))
353 {
354 WCHAR sNum[5];
355 if (ParseFieldW (wTemp, 2, sNum, 5))
356 icon_idx = _wtoi(sNum);
357 else
358 icon_idx = 0; /* sometimes the icon number is missing */
359 ParseFieldW (wTemp, 1, wTemp, MAX_PATH);
360 PathUnquoteSpacesW(wTemp);
361
362 if (!wcscmp(L"%1", wTemp)) /* icon is in the file */
363 {
364 ILGetDisplayNameExW(psf, pidl, wTemp, ILGDN_FORPARSING);
365 icon_idx = 0;
366
367 INT ret = PrivateExtractIconsW(wTemp, 0, 0, 0, NULL, NULL, 0, 0);
368 if (ret <= 0)
369 {
370 StringCbCopyW(wTemp, sizeof(wTemp), swShell32Name);
371 if (lstrcmpiW(pExtension, L".exe") == 0 || lstrcmpiW(pExtension, L".scr") == 0)
372 icon_idx = -IDI_SHELL_EXE;
373 else
374 icon_idx = -IDI_SHELL_DOCUMENT;
375 }
376 }
377
378 initIcon->SetNormalIcon(wTemp, icon_idx);
379 }
380 else
381 {
382 initIcon->SetNormalIcon(swShell32Name, 0);
383 }
384
385 if (hkey)
386 RegCloseKey(hkey);
387 }
388
389 return initIcon->QueryInterface(iid, ppvOut);
390}
391
392/*
393CFileSysEnum should do an initial FindFirstFile and do a FindNextFile as each file is
394returned by Next. When the enumerator is created, it can do numerous additional operations
395including formatting a drive, reconnecting a network share drive, and requesting a disk
396be inserted in a removable drive.
397*/
398
399
401 public CEnumIDListBase
402{
403private:
405 {
406#define SUPER_HIDDEN (FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM)
407
408 // Does it need special handling because it is hidden?
409 if (FindData.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN)
410 {
411 DWORD dwHidden = FindData.dwFileAttributes & SUPER_HIDDEN;
412
413 // Is it hidden, but are we not asked to include hidden?
414 if (dwHidden == FILE_ATTRIBUTE_HIDDEN && !(dwFlags & SHCONTF_INCLUDEHIDDEN))
415 return S_OK;
416
417 // Is it a system file, but are we not asked to include those?
418 if (dwHidden == SUPER_HIDDEN && !(dwFlags & SHCONTF_INCLUDESUPERHIDDEN))
419 return S_OK;
420 }
421
422 BOOL bDirectory = (FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
423
424 HRESULT hr;
425 if (bDirectory)
426 {
427 // Skip the current and parent directory nodes
428 if (!strcmpW(FindData.cFileName, L".") || !strcmpW(FindData.cFileName, L".."))
429 return S_OK;
430
431 // Does this directory need special handling?
432 if ((FindData.dwFileAttributes & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)) != 0)
433 {
434 WCHAR Tmp[MAX_PATH];
435 CLSID clsidFolder;
436
437 PathCombineW(Tmp, sParentDir, FindData.cFileName);
438
439 hr = SHELL32_GetCLSIDForDirectory(Tmp, L"CLSID", &clsidFolder);
440 if (SUCCEEDED(hr))
441 {
442 ERR("Got CLSID override for '%S'\n", Tmp);
443 }
444 }
445 }
446 else
447 {
448 CLSID clsidFile;
449 LPWSTR pExtension = PathFindExtensionW(FindData.cFileName);
450 if (pExtension)
451 {
452 // FIXME: Cache this?
453 hr = GetCLSIDForFileTypeFromExtension(pExtension, L"CLSID", &clsidFile);
454 if (hr == S_OK)
455 {
456 HKEY hkey;
457 hr = SHRegGetCLSIDKeyW(clsidFile, L"ShellFolder", FALSE, FALSE, &hkey);
458 if (SUCCEEDED(hr))
459 {
460 ::RegCloseKey(hkey);
461
462 // This should be presented as directory!
463 bDirectory = TRUE;
464 TRACE("Treating '%S' as directory!\n", FindData.cFileName);
465 }
466 }
467 }
468 }
469
470 LPITEMIDLIST pidl = NULL;
471 if (bDirectory)
472 {
473 if (dwFlags & SHCONTF_FOLDERS)
474 {
475 TRACE("(%p)-> (folder=%s)\n", this, debugstr_w(FindData.cFileName));
476 pidl = _ILCreateFromFindDataW(&FindData);
477 }
478 }
479 else
480 {
481 if (dwFlags & SHCONTF_NONFOLDERS)
482 {
483 TRACE("(%p)-> (file =%s)\n", this, debugstr_w(FindData.cFileName));
484 pidl = _ILCreateFromFindDataW(&FindData);
485 }
486 }
487
488 if (pidl && !AddToEnumList(pidl))
489 {
491 return E_FAIL;
492 }
493
494 return S_OK;
495 }
496
497public:
499 {
500
501 }
502
504 {
505 }
506
508 {
509 TRACE("(%p)->(path=%s flags=0x%08x)\n", this, debugstr_w(sPathTarget), dwFlags);
510
511 if (!sPathTarget || !sPathTarget[0])
512 {
513 WARN("No path for CFileSysEnum, empty result!\n");
514 return S_FALSE;
515 }
516
517 WCHAR szFindPattern[MAX_PATH];
518 HRESULT hr = StringCchCopyW(szFindPattern, _countof(szFindPattern), sPathTarget);
520 return hr;
521
522 /* FIXME: UNSAFE CRAP */
523 PathAddBackslashW(szFindPattern);
524
525 hr = StringCchCatW(szFindPattern, _countof(szFindPattern), L"*.*");
527 return hr;
528
529
530 WIN32_FIND_DATAW FindData;
531 HANDLE hFind = FindFirstFileW(szFindPattern, &FindData);
532 if (hFind == INVALID_HANDLE_VALUE)
534
535 do
536 {
537 hr = _AddFindResult(sPathTarget, FindData, dwFlags);
538
540 break;
541
542 } while(FindNextFileW(hFind, &FindData));
543
544 if (SUCCEEDED(hr))
545 {
546 DWORD dwError = GetLastError();
547 if (dwError != ERROR_NO_MORE_FILES)
548 {
549 hr = HRESULT_FROM_WIN32(dwError);
551 }
552 }
553 TRACE("(%p)->(hr=0x%08x)\n", this, hr);
554 FindClose(hFind);
555 return hr;
556 }
557
559 COM_INTERFACE_ENTRY_IID(IID_IEnumIDList, IEnumIDList)
561};
562
563
564/***********************************************************************
565 * IShellFolder implementation
566 */
567
569{
570 m_pclsid = &CLSID_ShellFSFolder;
574}
575
577{
578 TRACE("-- destroying IShellFolder(%p)\n", this);
579
582}
583
584static const shvheader GenericSFHeader[] = {
590 {IDS_SHV_COLUMN_COMMENTS, SHCOLSTATE_TYPE_STR | SHCOLSTATE_SLOW, LVCFMT_LEFT, 10}, // We don't currently support comments but CRegFolder does
591};
592
593#define GENERICSHELLVIEWCOLUMNS _countof(GenericSFHeader)
594
596{
597 if (iColumn >= _countof(GenericSFHeader))
598 return E_INVALIDARG;
599
600 sd.fmt = GenericSFHeader[iColumn].fmt;
601 sd.cxChar = GenericSFHeader[iColumn].cxChar;
602 return SHSetStrRet(&sd.str, GenericSFHeader[iColumn].colnameid);
603}
604
606{
607 if (iColumn >= _countof(GenericSFHeader))
608 return E_INVALIDARG;
609
610 csFlags = GenericSFHeader[iColumn].colstate;
611 return S_OK;
612}
613
615{
616 WCHAR wszCLSIDValue[CHARS_IN_GUID];
617 WCHAR wszDesktopIni[MAX_PATH];
618
619 StringCchCopyW(wszDesktopIni, MAX_PATH, pwszDir);
620 StringCchCatW(wszDesktopIni, MAX_PATH, L"\\desktop.ini");
621
622 if (GetPrivateProfileStringW(L".ShellClassInfo",
623 KeyName,
624 L"",
625 wszCLSIDValue,
627 wszDesktopIni))
628 {
629 return CLSIDFromString(wszCLSIDValue, pclsidFolder);
630 }
631 return E_FAIL;
632}
633
635{
636 DWORD dwFileAttributes, dwShellAttributes;
637
638 if (!_ILIsFolderOrFile(pidl))
639 {
640 ERR("Got wrong type of pidl!\n");
641 *pdwAttributes &= SFGAO_CANLINK;
642 return S_OK;
643 }
644
646
647 /* Set common attributes */
648 dwShellAttributes = SFGAO_CANCOPY | SFGAO_CANMOVE | SFGAO_CANLINK | SFGAO_CANRENAME | SFGAO_CANDELETE |
649 SFGAO_HASPROPSHEET | SFGAO_DROPTARGET | SFGAO_FILESYSTEM;
650
651 BOOL bDirectory = (dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
652
653 if (SFGAO_VALIDATE & *pdwAttributes)
654 {
655 STRRET strret;
656 LPWSTR path;
657 if (SUCCEEDED(psf->GetDisplayNameOf(pidl, SHGDN_FORPARSING, &strret)) &&
658 SUCCEEDED(StrRetToStrW(&strret, pidl, &path)))
659 {
660 BOOL exists = PathFileExistsW(path);
661 SHFree(path);
662 if (!exists)
663 return E_FAIL;
664 }
665 }
666
667 if (!bDirectory)
668 {
669 // https://git.reactos.org/?p=reactos.git;a=blob;f=dll/shellext/zipfldr/res/zipfldr.rgs;hb=032b5aacd233cd7b83ab6282aad638c161fdc400#l9
670 WCHAR szFileName[MAX_PATH];
671 LPWSTR pExtension;
672 BOOL hasName = _ILSimpleGetTextW(pidl, szFileName, _countof(szFileName));
673 dwShellAttributes |= SFGAO_STREAM;
674
675 // Vista+ feature: Hidden files with a leading tilde treated as super-hidden
676 // See https://devblogs.microsoft.com/oldnewthing/20170526-00/?p=96235
677 if (hasName && szFileName[0] == '~' && (dwFileAttributes & FILE_ATTRIBUTE_HIDDEN))
678 dwShellAttributes |= SFGAO_HIDDEN | SFGAO_SYSTEM;
679
680 if (hasName && (pExtension = PathFindExtensionW(szFileName)))
681 {
682 CLSID clsidFile;
683 // FIXME: Cache this?
684 HRESULT hr = GetCLSIDForFileTypeFromExtension(pExtension, L"CLSID", &clsidFile);
685 if (hr == S_OK)
686 {
687 HKEY hkey;
688 hr = SHRegGetCLSIDKeyW(clsidFile, L"ShellFolder", FALSE, FALSE, &hkey);
689 if (SUCCEEDED(hr))
690 {
692 DWORD dwSize = sizeof(dwAttributes);
694
696 if (Status == STATUS_SUCCESS)
697 {
698 TRACE("Augmenting '%S' with dwAttributes=0x%x\n", szFileName, dwAttributes);
699 dwShellAttributes |= dwAttributes;
700 }
701 ::RegCloseKey(hkey);
702
703 // This should be presented as directory!
704 bDirectory = (dwAttributes & SFGAO_FOLDER) != 0 || dwAttributes == 0;
705 TRACE("Treating '%S' as directory!\n", szFileName);
706 }
707 }
708 }
709 }
710
711 // This is a directory
712 if (bDirectory)
713 {
714 dwShellAttributes |= (SFGAO_FOLDER | /*SFGAO_HASSUBFOLDER |*/ SFGAO_STORAGE);
715
716 // Is this a real directory?
718 {
719 dwShellAttributes |= (SFGAO_FILESYSANCESTOR | SFGAO_STORAGEANCESTOR);
720 }
721 }
722
724 dwShellAttributes |= SFGAO_HIDDEN | SFGAO_GHOSTED;
725
727 dwShellAttributes |= SFGAO_READONLY;
728
730 dwShellAttributes |= SFGAO_SYSTEM;
731
733 dwShellAttributes |= SFGAO_COMPRESSED;
734
736 dwShellAttributes |= SFGAO_ENCRYPTED;
737
738 if ((SFGAO_NONENUMERATED & *pdwAttributes) && (dwFileAttributes & FILE_ATTRIBUTE_HIDDEN))
739 {
741 if ((!(shcf & SHCONTF_INCLUDEHIDDEN)) || ((dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) && !(shcf & SHCONTF_INCLUDESUPERHIDDEN)))
742 dwShellAttributes |= SFGAO_NONENUMERATED;
743 }
744
745 if (SFGAO_LINK & *pdwAttributes)
746 {
748
749 if (_ILGetExtension(pidl, ext, _countof(ext)) && !lstrcmpiW(ext, L"lnk"))
750 dwShellAttributes |= SFGAO_LINK;
751 }
752
753 if (SFGAO_HASSUBFOLDER & *pdwAttributes)
754 {
755 CComPtr<IShellFolder> psf2;
756 if (SUCCEEDED(psf->BindToObject(pidl, 0, IID_PPV_ARG(IShellFolder, &psf2))))
757 {
758 CComPtr<IEnumIDList> pEnumIL;
759 if (SUCCEEDED(psf2->EnumObjects(0, SHCONTF_FOLDERS, &pEnumIL)))
760 {
761 if (pEnumIL->Skip(1) == S_OK)
762 dwShellAttributes |= SFGAO_HASSUBFOLDER;
763 }
764 }
765 }
766
767 *pdwAttributes = dwShellAttributes;
768
769 TRACE ("-- 0x%08x\n", *pdwAttributes);
770 return S_OK;
771}
772
773// This method is typically invoked from SHSimpleIDListFromPathA/W.
775 _In_ LPOLESTR lpszDisplayName,
777 _Out_ LPITEMIDLIST *ppidl)
778{
779 HRESULT hr;
780 LPWSTR pchNext = lpszDisplayName;
781
782 *ppidl = NULL;
783
784 const DWORD finalattr = pFind->dwFileAttributes;
785 const DWORD finalsizelo = pFind->nFileSizeLow;
786 LPITEMIDLIST pidl;
787 for (hr = S_OK; SUCCEEDED(hr); hr = SHILAppend(pidl, ppidl))
788 {
789 hr = Shell_NextElement(&pchNext, pFind->cFileName, _countof(pFind->cFileName), FALSE);
790 if (hr != S_OK)
791 break;
792
793 pFind->dwFileAttributes = pchNext ? FILE_ATTRIBUTE_DIRECTORY : finalattr;
794 pFind->nFileSizeLow = pchNext ? 0 : finalsizelo;
795 pidl = _ILCreateFromFindDataW(pFind);
796 if (!pidl)
797 {
799 break;
800 }
801 }
802
803 if (SUCCEEDED(hr))
804 return S_OK;
805
806 if (*ppidl)
807 {
808 ILFree(*ppidl);
809 *ppidl = NULL;
810 }
811
812 return hr;
813}
814
816{
819 PathAppendW(szPath, pszName);
820
821 HANDLE hFind = ::FindFirstFileW(szPath, pFind);
822 if (hFind == INVALID_HANDLE_VALUE)
823 return FALSE;
824
825 ::FindClose(hFind);
826 return TRUE;
827}
828
830{
831 *ppidl = NULL;
832
833 if (PathIsDosDevice(pszName))
835
836 WIN32_FIND_DATAW FindData = { 0 };
837
838 HRESULT hr = S_OK;
839 if (attrs == ULONG_MAX) // Invalid attributes
840 {
841 if (!_GetFindDataFromName(pszName, &FindData))
843 }
844 else // Pretend as an item of attrs
845 {
846 StringCchCopyW(FindData.cFileName, _countof(FindData.cFileName), pszName);
847 FindData.dwFileAttributes = attrs;
848 }
849
850 if (FAILED(hr))
851 return hr;
852
853 *ppidl = _ILCreateFromFindDataW(&FindData);
854 if (!*ppidl)
855 return E_OUTOFMEMORY;
856
857 return S_OK;
858}
859
860/**************************************************************************
861* CFSFolder::ParseDisplayName {SHELL32}
862*
863* Parse a display name.
864*
865* PARAMS
866* hwndOwner [in] Parent window for any message's
867* pbc [in] optional FileSystemBindData context
868* lpszDisplayName [in] Unicode displayname.
869* pchEaten [out] (unicode) characters processed
870* ppidl [out] complex pidl to item
871* pdwAttributes [out] items attributes
872*
873* NOTES
874* Every folder tries to parse only its own (the leftmost) pidl and creates a
875* subfolder to evaluate the remaining parts.
876* Now we can parse into namespaces implemented by shell extensions
877*
878* Behaviour on win98: lpszDisplayName=NULL -> crash
879* lpszDisplayName="" -> returns mycoputer-pidl
880*
881* FIXME
882* pdwAttributes is not set
883* pchEaten is not set like in windows
884*/
886 LPBC pbc,
887 LPOLESTR lpszDisplayName,
888 DWORD *pchEaten, PIDLIST_RELATIVE *ppidl,
889 DWORD *pdwAttributes)
890{
891 TRACE ("(%p)->(HWND=%p,%p,%p=%s,%p,pidl=%p,%p)\n",
892 this, hwndOwner, pbc, lpszDisplayName, debugstr_w (lpszDisplayName),
893 pchEaten, ppidl, pdwAttributes);
894
895 if (!ppidl)
896 return E_INVALIDARG;
897
898 *ppidl = NULL;
899
900 if (!lpszDisplayName)
901 return E_INVALIDARG;
902
903 HRESULT hr;
904 WIN32_FIND_DATAW FindData;
905 if (SHIsFileSysBindCtx(pbc, &FindData) == S_OK)
906 {
907 CComHeapPtr<ITEMIDLIST> pidlTemp;
908 hr = _ParseSimple(lpszDisplayName, &FindData, &pidlTemp);
909 if (SUCCEEDED(hr) && pdwAttributes && *pdwAttributes)
910 {
911 LPCITEMIDLIST pidlLast = ILFindLastID(pidlTemp);
912 GetAttributesOf(1, &pidlLast, pdwAttributes);
913 }
914
915 if (SUCCEEDED(hr))
916 *ppidl = pidlTemp.Detach();
917 }
918 else
919 {
920 INT cchElement = lstrlenW(lpszDisplayName) + 1;
921 LPWSTR pszElement = (LPWSTR)_alloca(cchElement * sizeof(WCHAR));
922 LPWSTR pchNext = lpszDisplayName;
923 hr = Shell_NextElement(&pchNext, pszElement, cchElement, TRUE);
924 if (FAILED(hr))
925 return hr;
926
927 hr = _CreateIDListFromName(pszElement, ULONG_MAX, pbc, ppidl);
928 if (FAILED(hr))
929 {
930 if (pchNext) // Is there the next element?
931 {
932 // pszElement seems like a directory
933 if (_GetFindDataFromName(pszElement, &FindData) &&
934 (FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
935 {
936 hr = _CreateIDListFromName(pszElement, FILE_ATTRIBUTE_DIRECTORY, pbc, ppidl);
937 }
938 }
939 else
940 {
941 // pszElement seems like a non-directory
944 (BindCtx_GetMode(pbc, 0) & STGM_CREATE))
945 {
946 // Pretend like a normal file
947 hr = _CreateIDListFromName(pszElement, FILE_ATTRIBUTE_NORMAL, pbc, ppidl);
948 }
949 }
950 }
951
952 if (SUCCEEDED(hr))
953 {
954 if (pchNext) // Is there next?
955 {
956 CComPtr<IShellFolder> psfChild;
957 hr = BindToObject(*ppidl, pbc, IID_PPV_ARG(IShellFolder, &psfChild));
958 if (FAILED(hr))
959 return hr;
960
961 DWORD chEaten;
962 CComHeapPtr<ITEMIDLIST> pidlChild;
963 hr = psfChild->ParseDisplayName(hwndOwner, pbc, pchNext, &chEaten, &pidlChild,
964 pdwAttributes);
965
966 // Append pidlChild to ppidl
967 if (SUCCEEDED(hr))
968 hr = SHILAppend(pidlChild.Detach(), ppidl);
969 }
970 else if (pdwAttributes && *pdwAttributes)
971 {
972 GetAttributesOf(1, (LPCITEMIDLIST*)ppidl, pdwAttributes);
973 }
974 }
975 }
976
977 TRACE("(%p)->(-- pidl=%p ret=0x%08x)\n", this, ppidl ? *ppidl : 0, hr);
978
979 return hr;
980}
981
982/**************************************************************************
983* CFSFolder::EnumObjects
984* PARAMETERS
985* HWND hwndOwner, //[in ] Parent Window
986* DWORD grfFlags, //[in ] SHCONTF enumeration mask
987* LPENUMIDLIST* ppenumIDList //[out] IEnumIDList interface
988*/
990 HWND hwndOwner,
992 LPENUMIDLIST *ppEnumIDList)
993{
994 return ShellObjectCreatorInit<CFileSysEnum>(m_sPathTarget, dwFlags, IID_PPV_ARG(IEnumIDList, ppEnumIDList));
995}
996
997/**************************************************************************
998* CFSFolder::BindToObject
999* PARAMETERS
1000* LPCITEMIDLIST pidl, //[in ] relative pidl to open
1001* LPBC pbc, //[in ] optional FileSystemBindData context
1002* REFIID riid, //[in ] Initial Interface
1003* LPVOID* ppvObject //[out] Interface*
1004*/
1006 PCUIDLIST_RELATIVE pidl,
1007 LPBC pbc,
1008 REFIID riid,
1009 LPVOID * ppvOut)
1010{
1011 TRACE("(%p)->(pidl=%p,%p,%s,%p)\n", this, pidl, pbc,
1012 shdebugstr_guid(&riid), ppvOut);
1013
1014 CComPtr<IShellFolder> pSF;
1015 HRESULT hr;
1016
1017 if (!m_pidlRoot || !ppvOut || !pidl || !pidl->mkid.cb)
1018 {
1019 ERR("CFSFolder::BindToObject: Invalid parameters\n");
1020 return E_INVALIDARG;
1021 }
1022
1023 /* Get the pidl data */
1025 WCHAR szNameBuf[MAX_PATH];
1026 LPCWSTR pszName = GetItemFileName(pidl, szNameBuf, _countof(szNameBuf));
1027 if (!pszName)
1028 {
1029 ERR("CFSFolder::BindToObject: Invalid pidl!\n");
1030 return E_INVALIDARG;
1031 }
1032
1033 *ppvOut = NULL;
1034
1035 /* Create the target folder info */
1036 PERSIST_FOLDER_TARGET_INFO pfti = {0};
1037 pfti.dwAttributes = -1;
1038 pfti.csidl = -1;
1040
1041 /* Get the CLSID to bind to */
1042 CLSID clsidFolder;
1043 if (_ILIsFolder(pidl))
1044 {
1045 if ((pData->uFileAttribs & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)) != 0)
1046 {
1047 hr = SHELL32_GetCLSIDForDirectory(pfti.szTargetParsingName, L"CLSID", &clsidFolder);
1048
1049 if (SUCCEEDED(hr))
1050 {
1051 /* We got a GUID from a desktop.ini, let's try it */
1052 hr = SHELL32_BindToSF(m_pidlRoot, &pfti, pidl, &clsidFolder, riid, ppvOut);
1053 if (SUCCEEDED(hr))
1054 {
1055 TRACE("-- returning (%p) %08x, (%s)\n", *ppvOut, hr, wine_dbgstr_guid(&clsidFolder));
1056 return hr;
1057 }
1058
1059 /* Something went wrong, re-try it with a normal ShellFSFolder */
1060 ERR("CFSFolder::BindToObject: %s failed to bind, using fallback (0x%08x)\n", wine_dbgstr_guid(&clsidFolder), hr);
1061 }
1062 }
1063 /* No system folder or the custom class failed */
1064 clsidFolder = CLSID_ShellFSFolder;
1065 }
1066 else
1067 {
1068 hr = GetCLSIDForFileType(pidl, L"CLSID", &clsidFolder);
1069 if (hr == S_FALSE)
1071 if (hr != S_OK)
1072 return hr;
1073 }
1074
1075 hr = SHELL32_BindToSF(m_pidlRoot, &pfti, pidl, &clsidFolder, riid, ppvOut);
1077 return hr;
1078
1079 TRACE ("-- returning (%p) %08x\n", *ppvOut, hr);
1080
1081 return S_OK;
1082
1083}
1084
1085/**************************************************************************
1086* CFSFolder::BindToStorage
1087* PARAMETERS
1088* LPCITEMIDLIST pidl, //[in ] complex pidl to store
1089* LPBC pbc, //[in ] reserved
1090* REFIID riid, //[in ] Initial storage interface
1091* LPVOID* ppvObject //[out] Interface* returned
1092*/
1094 PCUIDLIST_RELATIVE pidl,
1095 LPBC pbcReserved,
1096 REFIID riid,
1097 LPVOID *ppvOut)
1098{
1099 FIXME("(%p)->(pidl=%p,%p,%s,%p) stub\n", this, pidl, pbcReserved,
1100 shdebugstr_guid (&riid), ppvOut);
1101
1102 *ppvOut = NULL;
1103 return E_NOTIMPL;
1104}
1105
1107{
1108 BOOL bIsFolder1 = _ILIsFolder(pidl1), bIsFolder2 = _ILIsFolder(pidl2);
1109 // When sorting between a File and a Folder, the Folder gets sorted first
1110 if (bIsFolder1 != bIsFolder2)
1111 {
1112 // ...but only if neither of them were generated by SHSimpleIDListFromPath
1113 // because in that case we cannot tell if it's a file or a folder.
1114 if (pidl1 && IsRealItem(*pidl1) && pidl2 && IsRealItem(*pidl2))
1115 return MAKE_COMPARE_HRESULT(bIsFolder1 ? -1 : 1);
1116 }
1118}
1119
1120/**************************************************************************
1121* CFSFolder::CompareIDs
1122*/
1123
1125 PCUIDLIST_RELATIVE pidl1,
1126 PCUIDLIST_RELATIVE pidl2)
1127{
1128 WCHAR szNameBuf1[MAX_PATH], szNameBuf2[_countof(szNameBuf1)];
1129 LPCWSTR pszName1 = GetItemFileName(pidl1, szNameBuf1, _countof(szNameBuf1));
1130 LPCWSTR pszName2 = GetItemFileName(pidl2, szNameBuf2, _countof(szNameBuf2));
1131 if (!pszName1 || !pszName2 || LOWORD(lParam) >= GENERICSHELLVIEWCOLUMNS)
1132 return E_INVALIDARG;
1133
1134 LPPIDLDATA pData1 = _ILGetDataPointer(pidl1);
1135 LPPIDLDATA pData2 = _ILGetDataPointer(pidl2);
1136 LPWSTR pExtension1, pExtension2;
1137
1138 HRESULT hr = CompareSortFoldersFirst(pidl1, pidl2);
1139 if (SUCCEEDED(hr))
1140 return hr;
1141 int result = 0;
1142 switch (LOWORD(lParam))
1143 {
1144 case SHFSF_COL_NAME:
1145 result = CompareUiStrings(pszName1, pszName2, lParam);
1146 break;
1147 case SHFSF_COL_SIZE:
1148 if (pData1->u.file.dwFileSize > pData2->u.file.dwFileSize)
1149 result = 1;
1150 else if (pData1->u.file.dwFileSize < pData2->u.file.dwFileSize)
1151 result = -1;
1152 else
1153 result = 0;
1154 break;
1155 case SHFSF_COL_TYPE:
1156 // FIXME: Compare the type strings from SHGetFileInfo
1157 pExtension1 = PathFindExtensionW(pszName1);
1158 pExtension2 = PathFindExtensionW(pszName2);
1159 result = CompareUiStrings(pExtension1, pExtension2, lParam);
1160 break;
1161 case SHFSF_COL_MDATE:
1162 result = pData1->u.file.uFileDate - pData2->u.file.uFileDate;
1163 if (result == 0)
1164 result = pData1->u.file.uFileTime - pData2->u.file.uFileTime;
1165 break;
1166 case SHFSF_COL_FATTS:
1167 return SHELL32_CompareDetails(this, lParam, pidl1, pidl2);
1168 case SHFSF_COL_COMMENT:
1169 result = 0;
1170 break;
1171 default:
1172 if (_ILIsPidlSimple(pidl1) || _ILIsPidlSimple(pidl2))
1173 ERR("Unknown column %u, can't compare\n", LOWORD(lParam));
1174 else
1175 TRACE("Unknown column %u, deferring to the subfolder\n", LOWORD(lParam));
1176 }
1177
1178 if (result == 0)
1179 return SHELL32_CompareChildren(this, lParam, pidl1, pidl2);
1180
1182}
1183
1184/**************************************************************************
1185* CFSFolder::CreateViewObject
1186*/
1188 REFIID riid, LPVOID * ppvOut)
1189{
1190 CComPtr<IShellView> pShellView;
1192
1193 TRACE ("(%p)->(hwnd=%p,%s,%p)\n", this, hwndOwner, shdebugstr_guid (&riid),
1194 ppvOut);
1195
1196 if (ppvOut)
1197 {
1198 *ppvOut = NULL;
1199
1200 BOOL bIsDropTarget = IsEqualIID (riid, IID_IDropTarget);
1201 BOOL bIsShellView = !bIsDropTarget && IsEqualIID (riid, IID_IShellView);
1202
1203 if (bIsDropTarget || bIsShellView)
1204 {
1205 DWORD dwDirAttributes = _ILGetFileAttributes(ILFindLastID(m_pidlRoot), NULL, 0);
1206
1207 if ((dwDirAttributes & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)) != 0)
1208 {
1209 CLSID clsidFolder;
1210 hr = SHELL32_GetCLSIDForDirectory(m_sPathTarget, L"UICLSID", &clsidFolder);
1211 if (SUCCEEDED(hr))
1212 {
1213 CComPtr<IPersistFolder> spFolder;
1214 hr = SHCoCreateInstance(NULL, &clsidFolder, NULL, IID_PPV_ARG(IPersistFolder, &spFolder));
1215 if (!FAILED_UNEXPECTEDLY(hr))
1216 {
1217 hr = spFolder->Initialize(m_pidlRoot);
1218
1219 if (!FAILED_UNEXPECTEDLY(hr))
1220 {
1221 hr = spFolder->QueryInterface(riid, ppvOut);
1222 }
1223 }
1224 }
1225 else
1226 {
1227 // No desktop.ini, or no UICLSID present, continue as if nothing happened
1228 hr = E_INVALIDARG;
1229 }
1230 }
1231 }
1232
1233 if (!SUCCEEDED(hr))
1234 {
1235 // No UICLSID handler found, continue to the default handlers
1236 if (bIsDropTarget)
1237 {
1239 }
1240 else if (IsEqualIID (riid, IID_IContextMenu))
1241 {
1242 HKEY hKeys[16];
1243 UINT cKeys = 0;
1244 AddClassKeyToArray(L"Directory\\Background", hKeys, &cKeys);
1245
1246 DEFCONTEXTMENU dcm;
1247 dcm.hwnd = hwndOwner;
1248 dcm.pcmcb = this;
1249 dcm.pidlFolder = m_pidlRoot;
1250 dcm.psf = this;
1251 dcm.cidl = 0;
1252 dcm.apidl = NULL;
1253 dcm.cKeys = cKeys;
1254 dcm.aKeys = hKeys;
1256 hr = SHCreateDefaultContextMenu (&dcm, riid, ppvOut);
1257 }
1258 else if (bIsShellView)
1259 {
1260 SFV_CREATE sfvparams = {sizeof(SFV_CREATE), this, NULL, this};
1261 hr = SHCreateShellFolderView(&sfvparams, (IShellView**)ppvOut);
1262 }
1263 else
1264 {
1265 hr = E_INVALIDARG;
1266 }
1267 }
1268 }
1269 TRACE("-- (%p)->(interface=%p)\n", this, ppvOut);
1270 return hr;
1271}
1272
1273/**************************************************************************
1274* CFSFolder::GetAttributesOf
1275*
1276* PARAMETERS
1277* UINT cidl, //[in ] num elements in pidl array
1278* LPCITEMIDLIST* apidl, //[in ] simple pidl array
1279* ULONG* rgfInOut) //[out] result array
1280*
1281*/
1283 PCUITEMID_CHILD_ARRAY apidl, DWORD * rgfInOut)
1284{
1285 HRESULT hr = S_OK;
1286
1287 if (!rgfInOut)
1288 return E_INVALIDARG;
1289 if (cidl && !apidl)
1290 return E_INVALIDARG;
1291
1292 if (*rgfInOut == 0)
1293 *rgfInOut = ~0;
1294
1295 if(cidl == 0)
1296 {
1298
1299 if (_ILIsFolderOrFile(rpidl))
1300 {
1301 SHELL32_GetFSItemAttributes(this, rpidl, rgfInOut);
1302 }
1303 else if (_ILIsDrive(rpidl))
1304 {
1305 IShellFolder *psfParent = NULL;
1307 if(SUCCEEDED(hr))
1308 {
1309 hr = psfParent->GetAttributesOf(1, &rpidl, (SFGAOF*)rgfInOut);
1310 psfParent->Release();
1311 }
1312 }
1313 else
1314 {
1315 ERR("Got and unknown pidl!\n");
1316 }
1317 }
1318 else
1319 {
1320 while (cidl > 0 && *apidl)
1321 {
1322 pdump(*apidl);
1323 if (_ILIsFolderOrFile(*apidl))
1324 SHELL32_GetFSItemAttributes(this, *apidl, rgfInOut);
1325 else
1326 ERR("Got an unknown type of pidl!!!\n");
1327 apidl++;
1328 cidl--;
1329 }
1330 }
1331 /* make sure SFGAO_VALIDATE is cleared, some apps depend on that */
1332 *rgfInOut &= ~SFGAO_VALIDATE;
1333
1334 TRACE("-- result=0x%08x\n", *rgfInOut);
1335
1336 return hr;
1337}
1338
1339/**************************************************************************
1340* CFSFolder::GetUIObjectOf
1341*
1342* PARAMETERS
1343* HWND hwndOwner, //[in ] Parent window for any output
1344* UINT cidl, //[in ] array size
1345* LPCITEMIDLIST* apidl, //[in ] simple pidl array
1346* REFIID riid, //[in ] Requested Interface
1347* UINT* prgfInOut, //[ ] reserved
1348* LPVOID* ppvObject) //[out] Resulting Interface
1349*
1350* NOTES
1351* This function gets asked to return "view objects" for one or more (multiple
1352* select) items:
1353* The viewobject typically is an COM object with one of the following
1354* interfaces:
1355* IExtractIcon,IDataObject,IContextMenu
1356* In order to support icon positions in the default Listview your DataObject
1357* must implement the SetData method (in addition to GetData :) - the shell
1358* passes a barely documented "Icon positions" structure to SetData when the
1359* drag starts, and GetData's it if the drop is in another explorer window that
1360* needs the positions.
1361*/
1363 UINT cidl, PCUITEMID_CHILD_ARRAY apidl,
1364 REFIID riid, UINT * prgfInOut,
1365 LPVOID * ppvOut)
1366{
1367 LPVOID pObj = NULL;
1369
1370 TRACE ("(%p)->(%p,%u,apidl=%p,%s,%p,%p)\n",
1371 this, hwndOwner, cidl, apidl, shdebugstr_guid (&riid), prgfInOut, ppvOut);
1372
1373 if (ppvOut)
1374 {
1375 *ppvOut = NULL;
1376
1377 if (cidl == 1 && _ILIsValue(apidl[0]))
1378 {
1379 hr = _CreateExtensionUIObject(apidl[0], riid, ppvOut);
1380 if(hr != S_FALSE)
1381 return hr;
1382 }
1383
1384 if (IsEqualIID(riid, IID_IContextMenu) && (cidl >= 1))
1385 {
1386 HKEY hKeys[16];
1387 UINT cKeys = 0;
1388 AddFSClassKeysToArray(cidl, apidl, hKeys, &cKeys);
1389
1390 DEFCONTEXTMENU dcm;
1391 dcm.hwnd = hwndOwner;
1392 dcm.pcmcb = this;
1393 dcm.pidlFolder = m_pidlRoot;
1394 dcm.psf = this;
1395 dcm.cidl = cidl;
1396 dcm.apidl = apidl;
1397 dcm.cKeys = cKeys;
1398 dcm.aKeys = hKeys;
1400 hr = SHCreateDefaultContextMenu (&dcm, riid, &pObj);
1401 }
1402 else if (IsEqualIID (riid, IID_IDataObject))
1403 {
1404 if (cidl >= 1)
1405 {
1406 hr = IDataObject_Constructor (hwndOwner, m_pidlRoot, apidl, cidl, TRUE, (IDataObject **)&pObj);
1407 }
1408 else
1409 {
1410 hr = E_INVALIDARG;
1411 }
1412 }
1413 else if ((IsEqualIID (riid, IID_IExtractIconA) || IsEqualIID (riid, IID_IExtractIconW)) && (cidl == 1))
1414 {
1415 if (_ILIsValue(apidl[0]))
1416 hr = _GetIconHandler(apidl[0], riid, (LPVOID*)&pObj);
1417 if (hr != S_OK)
1418 hr = CFSExtractIcon_CreateInstance(this, apidl[0], riid, &pObj);
1419 }
1420 else if (IsEqualIID (riid, IID_IDropTarget))
1421 {
1422 /* only interested in attempting to bind to shell folders, not files (except exe), so if we fail, rebind to root */
1423 if (cidl != 1 || FAILED(hr = this->_GetDropTarget(apidl[0], (LPVOID*) &pObj)))
1424 {
1426 }
1427 }
1428 else
1429 hr = E_NOINTERFACE;
1430
1431 if (SUCCEEDED(hr) && !pObj)
1432 hr = E_OUTOFMEMORY;
1433
1434 *ppvOut = pObj;
1435 }
1436 TRACE("(%p)->hr=0x%08x\n", this, hr);
1437 return hr;
1438}
1439
1440/******************************************************************************
1441 * SHELL_FS_HideExtension [Internal]
1442 *
1443 * Query the registry if the filename extension of a given path should be
1444 * hidden.
1445 *
1446 * PARAMS
1447 * szPath [I] Relative or absolute path of a file
1448 *
1449 * RETURNS
1450 * TRUE, if the filename's extension should be hidden
1451 * FALSE, otherwise.
1452 */
1454{
1455 HKEY hKey;
1456 BOOL doHide = FALSE; /* The default value is FALSE (win98 at least) */
1457 LONG lError;
1458
1459 doHide = !SHELL_GetSetting(SSF_SHOWEXTENSIONS, fShowExtensions);
1460
1461 if (!doHide)
1462 {
1464 if (*DotExt != 0)
1465 {
1467 LONG classlen = sizeof(classname);
1468 lError = RegQueryValueW(HKEY_CLASSES_ROOT, DotExt, classname, &classlen);
1469 if (lError == ERROR_SUCCESS)
1470 {
1472 if (lError == ERROR_SUCCESS)
1473 {
1474 lError = RegQueryValueExW(hKey, L"NeverShowExt", NULL, NULL, NULL, NULL);
1475 if (lError == ERROR_SUCCESS)
1476 doHide = TRUE;
1477
1479 }
1480 }
1481 }
1482 }
1483
1484 return doHide;
1485}
1486
1488{
1489 /*FIXME: MSDN also mentions SHGDN_FOREDITING which is not yet handled. */
1490 if (!(dwFlags & SHGDN_FORPARSING) &&
1491 ((dwFlags & SHGDN_INFOLDER) || (dwFlags == SHGDN_NORMAL))) {
1492 if (SHELL_FS_HideExtension(szPath) && szPath[0] != '.')
1494 }
1495}
1496
1497/**************************************************************************
1498* CFSFolder::GetDisplayNameOf
1499* Retrieves the display name for the specified file object or subfolder
1500*
1501* PARAMETERS
1502* LPCITEMIDLIST pidl, //[in ] complex pidl to item
1503* DWORD dwFlags, //[in ] SHGNO formatting flags
1504* LPSTRRET lpName) //[out] Returned display name
1505*
1506* FIXME
1507* if the name is in the pidl the ret value should be a STRRET_OFFSET
1508*/
1509
1511 DWORD dwFlags, LPSTRRET strRet)
1512{
1513 if (!strRet)
1514 return E_INVALIDARG;
1515
1516 /* If it is a complex pidl, let the child handle it */
1517 if (!_ILIsPidlSimple (pidl)) /* complex pidl */
1518 {
1519 return SHELL32_GetDisplayNameOfChild(this, pidl, dwFlags, strRet);
1520 }
1521 else if (pidl && !pidl->mkid.cb) /* empty pidl */
1522 {
1523 /* If it is an empty pidl return only the path of the folder */
1527 {
1528 return SHSetStrRet(strRet, m_sPathTarget);
1529 }
1530 return E_INVALIDARG;
1531 }
1532
1533 int len = 0;
1534 LPWSTR pszPath = (LPWSTR)CoTaskMemAlloc((MAX_PATH + 1) * sizeof(WCHAR));
1535 if (!pszPath)
1536 return E_OUTOFMEMORY;
1537
1541 {
1542 lstrcpynW(pszPath, m_sPathTarget, MAX_PATH);
1543 PathAddBackslashW(pszPath);
1544 len = wcslen(pszPath);
1545 }
1546 _ILSimpleGetTextW(pidl, pszPath + len, MAX_PATH + 1 - len);
1548
1549 strRet->uType = STRRET_WSTR;
1550 strRet->pOleStr = pszPath;
1551
1552 TRACE ("-- (%p)->(%s)\n", this, strRet->uType == STRRET_CSTR ? strRet->cStr : debugstr_w(strRet->pOleStr));
1553 return S_OK;
1554}
1555
1556/**************************************************************************
1557* CFSFolder::SetNameOf
1558* Changes the name of a file object or subfolder, possibly changing its item
1559* identifier in the process.
1560*
1561* PARAMETERS
1562* HWND hwndOwner, //[in ] Owner window for output
1563* LPCITEMIDLIST pidl, //[in ] simple pidl of item to change
1564* LPCOLESTR lpszName, //[in ] the items new display name
1565* DWORD dwFlags, //[in ] SHGNO formatting flags
1566* LPITEMIDLIST* ppidlOut) //[out] simple pidl returned
1567*/
1569 HWND hwndOwner,
1570 PCUITEMID_CHILD pidl,
1571 LPCOLESTR lpName,
1572 DWORD dwFlags,
1573 PITEMID_CHILD *pPidlOut)
1574{
1575 WCHAR szSrc[MAX_PATH + 1], szDest[MAX_PATH + 1], szNameBuf[MAX_PATH];
1576 BOOL bIsFolder = ItemIsFolder(ILFindLastID(pidl));
1577
1578 TRACE ("(%p)->(%p,pidl=%p,%s,%u,%p)\n", this, hwndOwner, pidl,
1579 debugstr_w (lpName), dwFlags, pPidlOut);
1580
1581 if (pPidlOut)
1582 *pPidlOut = NULL;
1583
1584 LPCWSTR pszName = GetItemFileName(pidl, szNameBuf, _countof(szNameBuf));
1585 if (!pszName)
1586 {
1587 ERR("Got garbage pidl:\n");
1588 pdump_always(pidl);
1589 return E_INVALIDARG;
1590 }
1591
1592 /* build source path */
1593 PathCombineW(szSrc, m_sPathTarget, pszName);
1594
1595 /* build destination path */
1598 else
1599 lstrcpynW(szDest, lpName, MAX_PATH);
1600
1601 if (!(dwFlags & SHGDN_FORPARSING) && !bIsFolder && SHELL_FS_HideExtension(szSrc))
1602 {
1604 if (*ext)
1605 PathAddExtensionW(szDest, ext);
1606 }
1607
1608 HRESULT hr = S_OK;
1609 TRACE ("src=%s dest=%s\n", debugstr_w(szSrc), debugstr_w(szDest));
1610 if (!wcscmp(szSrc, szDest))
1611 {
1612 /* src and destination is the same */
1613 if (pPidlOut)
1614 hr = SHILClone(pidl, pPidlOut);
1615 }
1616 else
1617 {
1618 hr = SHELL_SingleFileOperation(hwndOwner, FO_RENAME, szSrc, szDest, FOF_SILENT | FOF_ALLOWUNDO, NULL);
1619 if (SUCCEEDED(hr) && pPidlOut)
1620 hr = ParseDisplayName(hwndOwner, NULL, PathFindFileNameW(szDest), NULL, pPidlOut, NULL);
1621 }
1622 return hr;
1623}
1624
1626{
1627 FIXME ("(%p)\n", this);
1628 return E_NOTIMPL;
1629}
1630
1632{
1633 FIXME ("(%p)\n", this);
1634 return E_NOTIMPL;
1635}
1636
1638 ULONG * pSort, ULONG * pDisplay)
1639{
1640 TRACE ("(%p)\n", this);
1641
1642 if (pSort)
1643 *pSort = 0;
1644 if (pDisplay)
1645 *pDisplay = 0;
1646
1647 return S_OK;
1648}
1649
1651 SHCOLSTATEF *pcsFlags)
1652{
1653 TRACE ("(%p)\n", this);
1654
1655 if (!pcsFlags)
1656 return E_INVALIDARG;
1657 else
1658 return GetDefaultFSColumnState(iColumn, *pcsFlags);
1659}
1660
1662{
1663 if (!_ILGetFSType(pidl))
1664 return E_INVALIDARG;
1665 HRESULT hr;
1666 if (pscid->fmtid == FMTID_ShellDetails)
1667 {
1668 switch (pscid->pid)
1669 {
1670 case PID_DESCRIPTIONID:
1671 {
1673 return hr;
1674 SHDESCRIPTIONID *pDID = (SHDESCRIPTIONID*)V_ARRAY(pv)->pvData;
1675 if (ItemIsFolder(pidl))
1677 else if (_ILGetFSType(pidl) & PT_FS_FILE_FLAG)
1679 else
1681 if (FAILED(GetItemCLSID(pidl, &pDID->clsid)))
1682 pDID->clsid = CLSID_NULL;
1683 return S_OK;
1684 }
1685 }
1686 }
1687 // Handle non-string fields here when possible instead of deferring to GetDetailsOf
1688 const FileStruct &fsitem = ((PIDLDATA*)pidl->mkid.abID)->u.file;
1689 if (pscid->fmtid == FMTID_Storage)
1690 {
1691 switch (pscid->pid)
1692 {
1693 case PID_STG_NAME: // Handled directly here for faster performance
1694 return SHELL_GetDetailsOfAsStringVariant(this, pidl, SHFSF_COL_NAME, pv);
1695 case PID_STG_SIZE:
1696 V_VT(pv) = VT_UI4;
1697 V_UI4(pv) = _ILGetFileSize(pidl, NULL, 0);
1698 return S_OK;
1699 case PID_STG_ATTRIBUTES:
1700 V_VT(pv) = VT_UI4;
1701 V_UI4(pv) = fsitem.uFileAttribs;
1702 return S_OK;
1703 case PID_STG_WRITETIME:
1704 V_VT(pv) = VT_DATE;
1705 if (DosDateTimeToVariantTime(fsitem.uFileDate, fsitem.uFileTime, &V_DATE(pv)))
1706 return S_OK;
1707 break;
1708 }
1709 }
1710 return SH32_GetDetailsOfPKeyAsVariant(this, pidl, pscid, pv, TRUE);
1711}
1712
1714 UINT iColumn, SHELLDETAILS * psd)
1715{
1716 HRESULT hr = E_FAIL;
1717
1718 TRACE ("(%p)->(%p %i %p)\n", this, pidl, iColumn, psd);
1719
1720 if (!psd || iColumn >= GENERICSHELLVIEWCOLUMNS)
1721 return E_INVALIDARG;
1722
1723 if (!pidl)
1724 {
1725 /* the header titles */
1726 return GetFSColumnDetails(iColumn, *psd);
1727 }
1728 else
1729 {
1730 FILETIME ft;
1731 hr = S_OK;
1732 psd->str.uType = STRRET_WSTR;
1733 if (iColumn != SHFSF_COL_NAME)
1734 {
1735 psd->str.pOleStr = (LPWSTR)CoTaskMemAlloc(MAX_PATH * sizeof(WCHAR));
1736 if (!psd->str.pOleStr)
1737 return E_OUTOFMEMORY;
1738 }
1739 /* the data from the pidl */
1740 switch (iColumn)
1741 {
1742 case SHFSF_COL_NAME:
1744 break;
1745 case SHFSF_COL_SIZE:
1746 _ILGetFileSize(pidl, psd->str.pOleStr, MAX_PATH);
1747 break;
1748 case SHFSF_COL_TYPE:
1750 break;
1751 case SHFSF_COL_MDATE:
1752 if (!_ILGetFileDateTime(pidl, &ft) || FAILED(FormatDateTime(ft, psd->str.pOleStr, MAX_PATH)))
1753 {
1754 *psd->str.pOleStr = UNICODE_NULL;
1755 hr = S_FALSE;
1756 }
1757 break;
1758 case SHFSF_COL_FATTS:
1760 break;
1761 case SHFSF_COL_COMMENT:
1762 psd->str.pOleStr[0] = UNICODE_NULL; // TODO: Extract comment from .lnk files? desktop.ini?
1763 break;
1764#if DBG
1765 default:
1766 ERR("Missing case for column %d\n", iColumn);
1767#else
1769#endif
1770 }
1771 }
1772
1773 return hr;
1774}
1775
1777{
1778 switch (column)
1779 {
1780 case SHFSF_COL_NAME: return MakeSCID(*pscid, FMTID_Storage, PID_STG_NAME);
1781 case SHFSF_COL_SIZE: return MakeSCID(*pscid, FMTID_Storage, PID_STG_SIZE);
1782 case SHFSF_COL_TYPE: return MakeSCID(*pscid, FMTID_Storage, PID_STG_STORAGETYPE);
1783 case SHFSF_COL_MDATE: return MakeSCID(*pscid, FMTID_Storage, PID_STG_WRITETIME);
1784 case SHFSF_COL_FATTS: return MakeSCID(*pscid, FMTID_Storage, PID_STG_ATTRIBUTES);
1785 case SHFSF_COL_COMMENT: return MakeSCID(*pscid, FMTID_SummaryInformation, PIDSI_COMMENTS);
1786 }
1787 return E_INVALIDARG;
1788}
1789
1790/************************************************************************
1791 * CFSFolder::GetClassID
1792 */
1794{
1795 TRACE ("(%p)\n", this);
1796
1797 if (!lpClassId)
1798 return E_POINTER;
1799
1800 *lpClassId = *m_pclsid;
1801
1802 return S_OK;
1803}
1804
1805/************************************************************************
1806 * CFSFolder::Initialize
1807 *
1808 * NOTES
1809 * m_sPathTarget is not set. Don't know how to handle in a non rooted environment.
1810 */
1812{
1813 WCHAR wszTemp[MAX_PATH];
1814
1815 TRACE ("(%p)->(%p)\n", this, pidl);
1816
1817 SHFree(m_pidlRoot); /* free the old pidl */
1818 m_pidlRoot = ILClone (pidl); /* set my pidl */
1819
1822
1823 /* set my path */
1824 HRESULT hr = E_FAIL;
1825 if (SHGetPathFromIDListW (pidl, wszTemp))
1826 hr = SHStrDupW(wszTemp, &m_sPathTarget);
1827
1828 TRACE ("--(%p)->(%s)\n", this, debugstr_w(m_sPathTarget));
1829 return hr;
1830}
1831
1832/**************************************************************************
1833 * CFSFolder::GetCurFolder
1834 */
1836{
1837 TRACE ("(%p)->(%p)\n", this, pidl);
1838
1839 if (!pidl)
1840 return E_POINTER;
1841
1842 *pidl = ILClone(m_pidlRoot);
1843 return S_OK;
1844}
1845
1846/**************************************************************************
1847 * CFSFolder::InitializeEx
1848 *
1849 * FIXME: error handling
1850 */
1852 const PERSIST_FOLDER_TARGET_INFO * ppfti)
1853{
1854 WCHAR wszTemp[MAX_PATH];
1855
1856 TRACE("(%p)->(%p,%p,%p)\n", this, pbc, pidlRootx, ppfti);
1857 if (ppfti)
1858 TRACE("--%p %s %s 0x%08x 0x%08x\n",
1860 debugstr_w (ppfti->szNetworkProvider), ppfti->dwAttributes,
1861 ppfti->csidl);
1862
1863 pdump (pidlRootx);
1864 if (ppfti && ppfti->pidlTargetFolder)
1865 pdump(ppfti->pidlTargetFolder);
1866
1867 if (m_pidlRoot)
1868 __SHFreeAndNil(&m_pidlRoot); /* free the old */
1869 if (m_sPathTarget)
1871
1872 /*
1873 * Root path and pidl
1874 */
1875 m_pidlRoot = ILClone(pidlRootx);
1876
1877 /*
1878 * the target folder is spezified in csidl OR pidlTargetFolder OR
1879 * szTargetParsingName
1880 */
1881 HRESULT hr = E_FAIL;
1882 if (ppfti)
1883 {
1884 if (ppfti->csidl != -1)
1885 {
1887 if (SHGetSpecialFolderPathW(0, wszTemp, ppfti->csidl, create))
1888 hr = SHStrDupW(wszTemp, &m_sPathTarget);
1889 }
1890 else if (ppfti->szTargetParsingName[0])
1891 {
1893 }
1894 else if (ppfti->pidlTargetFolder)
1895 {
1896 if (SHGetPathFromIDListW(ppfti->pidlTargetFolder, wszTemp))
1897 hr = SHStrDupW(wszTemp, &m_sPathTarget);
1898 }
1899 }
1900 TRACE("--(%p)->(target=%s)\n", this, debugstr_w(m_sPathTarget));
1902 return hr;
1903}
1904
1906{
1907 FIXME("(%p)->(%p)\n", this, ppfti);
1908 ZeroMemory(ppfti, sizeof (*ppfti));
1909 return E_NOTIMPL;
1910}
1911
1913{
1915
1916 sprintfW(buf, L"ShellEx\\{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
1917 riid.Data1, riid.Data2, riid.Data3,
1918 riid.Data4[0], riid.Data4[1], riid.Data4[2], riid.Data4[3],
1919 riid.Data4[4], riid.Data4[5], riid.Data4[6], riid.Data4[7]);
1920
1921 CLSID clsid;
1922 HRESULT hr;
1923
1924 hr = GetCLSIDForFileType(pidl, buf, &clsid);
1925 if (hr != S_OK)
1926 return hr;
1927
1928 hr = _CreateShellExtInstance(&clsid, pidl, riid, ppvOut);
1930 return hr;
1931
1932 return S_OK;
1933}
1934
1936{
1937 HRESULT hr;
1938
1939 TRACE("CFSFolder::_GetDropTarget entered\n");
1940
1941 if (_ILIsFolder (pidl))
1942 {
1943 CComPtr<IShellFolder> psfChild;
1944 hr = this->BindToObject(pidl, NULL, IID_PPV_ARG(IShellFolder, &psfChild));
1946 return hr;
1947
1948 return psfChild->CreateViewObject(NULL, IID_IDropTarget, ppvOut);
1949 }
1950
1951 CLSID clsid;
1952 hr = GetCLSIDForFileType(pidl, L"shellex\\DropHandler", &clsid);
1953 if (hr != S_OK)
1954 return hr;
1955
1956 hr = _CreateShellExtInstance(&clsid, pidl, IID_IDropTarget, ppvOut);
1958 return S_FALSE;
1959
1960 return S_OK;
1961}
1962
1964{
1965 CLSID clsid;
1966 HRESULT hr;
1967
1968 hr = GetCLSIDForFileType(pidl, L"shellex\\IconHandler", &clsid);
1969 if (hr != S_OK)
1970 return hr;
1971
1972 hr = _CreateShellExtInstance(&clsid, pidl, riid, ppvOut);
1974 return S_FALSE;
1975
1976 return S_OK;
1977}
1978
1980{
1981 HRESULT hr;
1982 WCHAR wszPath[MAX_PATH], szNameBuf[MAX_PATH];
1983
1984 LPCWSTR pszName = GetItemFileName(pidl, szNameBuf, _countof(szNameBuf));
1985 if (!pszName)
1986 {
1987 ERR("Got garbage pidl\n");
1988 pdump_always(pidl);
1989 return E_INVALIDARG;
1990 }
1991 PathCombineW(wszPath, m_sPathTarget, pszName);
1992
1993 CComPtr<IPersistFile> pp;
1996 return hr;
1997
1998 pp->Load(wszPath, 0);
1999
2000 hr = pp->QueryInterface(riid, ppvOut);
2001 if (hr != S_OK)
2002 {
2003 ERR("Failed to query for interface IID_IShellExtInit hr %x pclsid %s\n", hr, wine_dbgstr_guid(pclsid));
2004 return hr;
2005 }
2006 return hr;
2007}
2008
2010{
2011 enum { IDC_PROPERTIES };
2012 /* no data object means no selection */
2013 if (!pdtobj)
2014 {
2015 if (uMsg == DFM_INVOKECOMMAND && wParam == IDC_PROPERTIES)
2016 {
2018 }
2019 else if (uMsg == DFM_MERGECONTEXTMENU)
2020 {
2021 QCMINFO *pqcminfo = (QCMINFO *)lParam;
2022 HMENU hpopup = CreatePopupMenu();
2024 pqcminfo->idCmdFirst = Shell_MergeMenus(pqcminfo->hmenu, hpopup, pqcminfo->indexMenu, pqcminfo->idCmdFirst, pqcminfo->idCmdLast, MM_ADDSEPARATOR);
2025 DestroyMenu(hpopup);
2026 return S_OK;
2027 }
2028 }
2029 return SHELL32_DefaultContextMenuCallBack(psf, pdtobj, uMsg);
2030}
2031
2033{
2034 // create stream from file
2035 HRESULT hr;
2036 CComPtr<IStream> pStream;
2038 FALSE, NULL, &pStream);
2039 if (FAILED(hr))
2040 return NULL;
2041
2042 // load the picture
2043 HBITMAP hbm = NULL;
2044 CComPtr<IPicture> pPicture;
2045 OleLoadPicture(pStream, 0, FALSE, IID_IPicture, (LPVOID *)&pPicture);
2046
2047 // get the bitmap handle
2048 if (pPicture)
2049 {
2050 pPicture->get_Handle((OLE_HANDLE *)&hbm);
2051
2052 // copy the bitmap handle
2054 }
2055
2056 return hbm;
2057}
2058
2060{
2061 if (data == NULL)
2062 {
2063 return E_POINTER;
2064 }
2065 if (data->cbSize != sizeof(*data))
2066 {
2067 // NOTE: You have to set the cbData member before SFVM_GET_CUSTOMVIEWINFO call.
2068 return E_INVALIDARG;
2069 }
2070
2071 data->hbmBack = NULL;
2072 data->clrText = CLR_INVALID;
2073 data->clrTextBack = CLR_INVALID;
2074
2076
2077 // does the folder exists?
2079 {
2080 return E_INVALIDARG;
2081 }
2082
2083 // don't use custom view in network path for security
2085 {
2086 return E_ACCESSDENIED;
2087 }
2088
2089 // build the ini file path
2091 PathAppend(szIniFile, L"desktop.ini");
2092
2093 static LPCWSTR TheGUID = L"{BE098140-A513-11D0-A3A4-00C04FD706EC}";
2094 static LPCWSTR Space = L" \t\n\r\f\v";
2095
2096 // get info from ini file
2097 WCHAR szImage[MAX_PATH], szText[64];
2098
2099 // load the image
2100 szImage[0] = UNICODE_NULL;
2101 GetPrivateProfileStringW(TheGUID, L"IconArea_Image", L"", szImage, _countof(szImage), szIniFile);
2102 if (szImage[0])
2103 {
2104 StrTrimW(szImage, Space);
2105 if (PathIsRelativeW(szImage))
2106 {
2107 PathAppendW(szPath, szImage);
2108 StringCchCopyW(szImage, _countof(szImage), szPath);
2109 }
2110 data->hbmBack = DoLoadPicture(szImage);
2111 }
2112
2113 // load the text color
2114 szText[0] = UNICODE_NULL;
2115 GetPrivateProfileStringW(TheGUID, L"IconArea_Text", L"", szText, _countof(szText), szIniFile);
2116 if (szText[0])
2117 {
2118 StrTrimW(szText, Space);
2119
2120 LPWSTR pchEnd = NULL;
2121 COLORREF cr = (wcstol(szText, &pchEnd, 0) & 0xFFFFFF);
2122
2123 if (pchEnd && !*pchEnd)
2124 data->clrText = cr;
2125 }
2126
2127 // load the text background color
2128 szText[0] = UNICODE_NULL;
2129 GetPrivateProfileStringW(TheGUID, L"IconArea_TextBackground", L"", szText, _countof(szText), szIniFile);
2130 if (szText[0])
2131 {
2132 StrTrimW(szText, Space);
2133
2134 LPWSTR pchEnd = NULL;
2135 COLORREF cr = (wcstol(szText, &pchEnd, 0) & 0xFFFFFF);
2136
2137 if (pchEnd && !*pchEnd)
2138 data->clrTextBack = cr;
2139 }
2140
2141 if (data->hbmBack != NULL || data->clrText != CLR_INVALID || data->clrTextBack != CLR_INVALID)
2142 return S_OK;
2143
2144 return E_FAIL;
2145}
2146
2148{
2150 switch (uMsg)
2151 {
2154 break;
2155 case SFVM_GETCOMMANDDIR:
2156 if (m_sPathTarget)
2158 break;
2159 }
2160 return hr;
2161}
2162
2164{
2165 FILETIME lft;
2167 FileTimeToLocalFileTime(&ft, &lft);
2168 FileTimeToSystemTime(&lft, &time);
2170 if (ret > 0 && ret < cchBuf)
2171 {
2172 /* Append space + time without seconds */
2173 Buf[ret-1] = ' ';
2175 }
2176 return ret ? S_OK : E_FAIL;
2177}
2178
2180{
2181 if (StrFormatKBSizeW(size, Buf, cchBuf))
2182 return S_OK;
2183 if (cchBuf)
2184 *Buf = UNICODE_NULL;
2185 return E_FAIL;
2186}
HRESULT WINAPI SHCreateShellFolderView(const SFV_CREATE *pcsfv, IShellView **ppsv)
Definition: CDefView.cpp:4782
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:108
#define RegCloseKey(hKey)
Definition: registry.h:49
BOOL AddToEnumList(LPITEMIDLIST pidl)
STDMETHOD() GetDisplayNameOf(PCUITEMID_CHILD pidl, DWORD dwFlags, LPSTRRET strRet) override
Definition: CFSFolder.cpp:1510
STDMETHOD() CallBack(IShellFolder *psf, HWND hwndOwner, IDataObject *pdtobj, UINT uMsg, WPARAM wParam, LPARAM lParam) override
Definition: CFSFolder.cpp:2009
STDMETHOD() Initialize(PCIDLIST_ABSOLUTE pidl) override
Definition: CFSFolder.cpp:1811
STDMETHOD() EnumObjects(HWND hwndOwner, DWORD dwFlags, LPENUMIDLIST *ppEnumIDList) override
Definition: CFSFolder.cpp:989
HRESULT _CreateShellExtInstance(const CLSID *pclsid, LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppvOut)
Definition: CFSFolder.cpp:1979
static HRESULT GetDefaultFSColumnState(UINT iColumn, SHCOLSTATEF &csFlags)
Definition: CFSFolder.cpp:605
STDMETHOD() SetNameOf(HWND hwndOwner, PCUITEMID_CHILD pidl, LPCOLESTR lpName, DWORD dwFlags, PITEMID_CHILD *pPidlOut) override
Definition: CFSFolder.cpp:1568
DWORD m_bGroupPolicyActive
Definition: CFSFolder.h:31
static HRESULT CompareSortFoldersFirst(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
Definition: CFSFolder.cpp:1106
static HRESULT FormatSize(UINT64 size, LPWSTR Buf, UINT cchBuf)
Definition: CFSFolder.cpp:2179
HRESULT _GetIconHandler(LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppvOut)
Definition: CFSFolder.cpp:1963
LPWSTR m_sPathTarget
Definition: CFSFolder.h:27
STDMETHOD() GetAttributesOf(UINT cidl, PCUITEMID_CHILD_ARRAY apidl, DWORD *rgfInOut) override
Definition: CFSFolder.cpp:1282
HRESULT _ParseSimple(_In_ LPOLESTR lpszDisplayName, _Inout_ WIN32_FIND_DATAW *pFind, _Out_ LPITEMIDLIST *ppidl)
Definition: CFSFolder.cpp:774
static HRESULT GetFSColumnDetails(UINT iColumn, SHELLDETAILS &sd)
Definition: CFSFolder.cpp:595
STDMETHOD() CompareIDs(LPARAM lParam, PCUIDLIST_RELATIVE pidl1, PCUIDLIST_RELATIVE pidl2) override
Definition: CFSFolder.cpp:1124
STDMETHOD() GetCurFolder(PIDLIST_ABSOLUTE *pidl) override
Definition: CFSFolder.cpp:1835
BOOL _GetFindDataFromName(_In_ LPCWSTR pszName, _Out_ WIN32_FIND_DATAW *pFind)
Definition: CFSFolder.cpp:815
STDMETHOD() GetUIObjectOf(HWND hwndOwner, UINT cidl, PCUITEMID_CHILD_ARRAY apidl, REFIID riid, UINT *prgfInOut, LPVOID *ppvOut) override
Definition: CFSFolder.cpp:1362
HRESULT _GetDropTarget(LPCITEMIDLIST pidl, LPVOID *ppvOut)
Definition: CFSFolder.cpp:1935
HRESULT _CreateIDListFromName(LPCWSTR pszName, DWORD attrs, IBindCtx *pbc, LPITEMIDLIST *ppidl)
Definition: CFSFolder.cpp:829
STDMETHOD() MapColumnToSCID(UINT column, SHCOLUMNID *pscid) override
Definition: CFSFolder.cpp:1776
const CLSID * m_pclsid
Definition: CFSFolder.h:24
STDMETHOD() BindToStorage(PCUIDLIST_RELATIVE pidl, LPBC pbcReserved, REFIID riid, LPVOID *ppvOut) override
Definition: CFSFolder.cpp:1093
STDMETHOD() ParseDisplayName(HWND hwndOwner, LPBC pbc, LPOLESTR lpszDisplayName, DWORD *pchEaten, PIDLIST_RELATIVE *ppidl, DWORD *pdwAttributes) override
Definition: CFSFolder.cpp:885
STDMETHOD() InitializeEx(IBindCtx *pbc, LPCITEMIDLIST pidlRoot, const PERSIST_FOLDER_TARGET_INFO *ppfti) override
Definition: CFSFolder.cpp:1851
STDMETHOD() GetDefaultColumnState(UINT iColumn, DWORD *pcsFlags) override
Definition: CFSFolder.cpp:1650
HRESULT WINAPI GetCustomViewInfo(ULONG unknown, SFVM_CUSTOMVIEWINFO_DATA *data)
Definition: CFSFolder.cpp:2059
STDMETHOD() MessageSFVCB(UINT uMsg, WPARAM wParam, LPARAM lParam) override
Definition: CFSFolder.cpp:2147
LPITEMIDLIST m_pidlRoot
Definition: CFSFolder.h:29
static HRESULT FormatDateTime(const FILETIME &ft, LPWSTR Buf, UINT cchBuf)
Definition: CFSFolder.cpp:2163
STDMETHOD() GetFolderTargetInfo(PERSIST_FOLDER_TARGET_INFO *ppfti) override
Definition: CFSFolder.cpp:1905
STDMETHOD() GetDetailsEx(PCUITEMID_CHILD pidl, const SHCOLUMNID *pscid, VARIANT *pv) override
Definition: CFSFolder.cpp:1661
STDMETHOD() EnumSearches(IEnumExtraSearch **ppenum) override
Definition: CFSFolder.cpp:1631
STDMETHOD() GetDefaultSearchGUID(GUID *pguid) override
Definition: CFSFolder.cpp:1625
STDMETHOD() GetClassID(CLSID *lpClassId) override
Definition: CFSFolder.cpp:1793
STDMETHOD() CreateViewObject(HWND hwndOwner, REFIID riid, LPVOID *ppvOut) override
Definition: CFSFolder.cpp:1187
STDMETHOD() GetDefaultColumn(DWORD dwRes, ULONG *pSort, ULONG *pDisplay) override
Definition: CFSFolder.cpp:1637
STDMETHOD() BindToObject(PCUIDLIST_RELATIVE pidl, LPBC pbcReserved, REFIID riid, LPVOID *ppvOut) override
Definition: CFSFolder.cpp:1005
static int CompareUiStrings(LPCWSTR a, LPCWSTR b, LPARAM lParam=0)
Definition: CFSFolder.h:136
HRESULT _CreateExtensionUIObject(LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppvOut)
Definition: CFSFolder.cpp:1912
STDMETHOD() GetDetailsOf(PCUITEMID_CHILD pidl, UINT iColumn, SHELLDETAILS *psd) override
Definition: CFSFolder.cpp:1713
HRESULT _AddFindResult(LPWSTR sParentDir, const WIN32_FIND_DATAW &FindData, DWORD dwFlags)
Definition: CFSFolder.cpp:404
HRESULT WINAPI Initialize(LPWSTR sPathTarget, DWORD dwFlags)
Definition: CFSFolder.cpp:507
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:89
#define IDS_SHV_COLUMN_NAME
Definition: resource.h:88
#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
@ VT_DATE
Definition: compat.h:2302
@ VT_UI4
Definition: compat.h:2313
#define lstrcpynW
Definition: compat.h:738
#define lstrlenW
Definition: compat.h:750
static const WCHAR *const ext[]
Definition: module.c:53
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
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:1453
static HRESULT SHELL32_GetCLSIDForDirectory(LPCWSTR pwszDir, LPCWSTR KeyName, CLSID *pclsidFolder)
Definition: CFSFolder.cpp:614
#define GENERICSHELLVIEWCOLUMNS
Definition: CFSFolder.cpp:593
static BOOL getShellClassInfo(LPCWSTR Entry, LPWSTR pszValue, DWORD cchValueLen, LPCWSTR IniFile)
Definition: CFSFolder.cpp:214
static void GetItemDescription(PCUITEMID_CHILD pidl, LPWSTR Buf, UINT cchMax)
Definition: CFSFolder.cpp:44
static LPCWSTR ExtensionFromPidl(PCUIDLIST_RELATIVE pidl, LPWSTR Buf, UINT cchMax, BOOL AllowFolder=FALSE)
Definition: CFSFolder.cpp:91
#define SUPER_HIDDEN
static HRESULT getIconLocationForFolder(IShellFolder *psf, PCITEMID_CHILD pidl, UINT uFlags, LPWSTR szIconFile, UINT cchMax, int *piIndex, UINT *pwFlags)
Definition: CFSFolder.cpp:220
HRESULT SHELL32_GetFSItemAttributes(IShellFolder *psf, LPCITEMIDLIST pidl, LPDWORD pdwAttributes)
Definition: CFSFolder.cpp:634
static HRESULT getDefaultIconLocation(LPWSTR szIconFile, UINT cchMax, int *piIndex, UINT uFlags)
Definition: CFSFolder.cpp:190
static const shvheader GenericSFHeader[]
Definition: CFSFolder.cpp:584
HRESULT GetCLSIDForFileType(PCUIDLIST_RELATIVE pidl, LPCWSTR KeyName, CLSID *pclsid)
Definition: CFSFolder.cpp:164
HRESULT GetItemCLSID(PCUIDLIST_RELATIVE pidl, CLSID *pclsid)
Definition: CFSFolder.cpp:174
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:1487
HRESULT CFSExtractIcon_CreateInstance(IShellFolder *psf, LPCITEMIDLIST pidl, REFIID iid, LPVOID *ppvOut)
Definition: CFSFolder.cpp:296
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:2032
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 SHELL_SingleFileOperation(HWND hWnd, UINT Op, PCWSTR Src, PCWSTR Dest, UINT Flags, PWSTR *ppNewName)
Definition: shlfileop.cpp:2446
HRESULT SHELL32_DefaultContextMenuCallBack(IShellFolder *psf, IDataObject *pdo, UINT msg)
Definition: shlfolder.cpp:613
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:3219
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
#define FAILED_UNEXPECTEDLY
Definition: utils.cpp:30
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:205
#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:1089
INT WINAPI GetDateFormatW(LCID lcid, DWORD dwFlags, const SYSTEMTIME *lpTime, LPCWSTR lpFormat, LPWSTR lpDateStr, INT cchOut)
Definition: lcformat.c:989
#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
if(dx< 0)
Definition: linetemp.h:194
#define PT_FS_UNICODE_FLAG
Definition: lnktool.cpp:41
#define PT_FS
Definition: lnktool.cpp:40
__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 PID_STG_STORAGETYPE
Definition: ntquery.h:50
#define PID_STG_WRITETIME
Definition: ntquery.h:60
#define PID_STG_SIZE
Definition: ntquery.h:58
#define PID_STG_ATTRIBUTES
Definition: ntquery.h:59
#define PID_STG_NAME
Definition: ntquery.h:56
#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 FMTID FMTID_SummaryInformation
#define V_ARRAY(A)
Definition: oleauto.h:222
#define V_VT(A)
Definition: oleauto.h:211
#define V_UI4(A)
Definition: oleauto.h:270
#define V_DATE(A)
Definition: oleauto.h:231
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:2578
LPITEMIDLIST WINAPI ILFindLastID(LPCITEMIDLIST pidl)
Definition: pidl.c:198
LPPIDLDATA _ILGetDataPointer(LPCITEMIDLIST pidl)
Definition: pidl.c:2271
HRESULT WINAPI SHBindToParent(LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppv, LPCITEMIDLIST *ppidlLast)
Definition: pidl.c:1497
FileStructW * _ILGetFileStructW(LPCITEMIDLIST pidl)
Definition: pidl.c:2443
BOOL _ILIsFolder(LPCITEMIDLIST pidl)
Definition: pidl.c:2137
BOOL WINAPI SHGetPathFromIDListW(LPCITEMIDLIST pidl, LPWSTR pszPath)
Definition: pidl.c:1489
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:2485
DWORD _ILGetFileSize(LPCITEMIDLIST pidl, LPWSTR pOut, UINT uOutSize)
Definition: pidl.c:2512
BOOL _ILIsValue(LPCITEMIDLIST pidl)
Definition: pidl.c:2144
BOOL _ILIsDrive(LPCITEMIDLIST pidl)
Definition: pidl.c:2130
BOOL _ILGetExtension(LPCITEMIDLIST pidl, LPWSTR pOut, UINT uOutSize)
Definition: pidl.c:2531
DWORD _ILSimpleGetTextW(LPCITEMIDLIST pidl, LPWSTR szOut, UINT uOutSize)
Definition: pidl.c:2191
LPITEMIDLIST _ILCreateFromFindDataW(const WIN32_FIND_DATAW *wfd)
Definition: pidl.c:1933
static BYTE _ILGetType(LPCITEMIDLIST pidl)
Definition: pidl.h:144
static BYTE _ILGetFSType(LPCITEMIDLIST pidl)
Definition: pidl.h:149
#define LVCFMT_LEFT
Definition: commctrl.h:2603
#define LVCFMT_RIGHT
Definition: commctrl.h:2604
#define CLSID_NULL
Definition: guiddef.h:99
#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 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:161
static HRESULT SHELL_CreateVariantBuffer(VARIANT *pVar, UINT cb)
Definition: shell32_main.h:234
DWORD WINAPI ParseFieldW(LPCWSTR src, DWORD nField, LPWSTR dst, DWORD len) DECLSPEC_HIDDEN
Definition: shellord.c:117
#define FO_RENAME
Definition: shellapi.h:140
#define FOF_ALLOWUNDO
Definition: shellapi.h:148
#define FOF_SILENT
Definition: shellapi.h:144
#define CSIDL_FLAG_CREATE
#define STATUS_SUCCESS
Definition: shellext.h:65
#define MAKE_COMPARE_HRESULT(x)
Definition: shellutils.h:663
#define SHELL_GetSetting(pss, ssf, field)
Definition: shellutils.h:876
#define S_EQUAL
Definition: shellutils.h:661
HRESULT SH32_GetDetailsOfPKeyAsVariant(IShellFolder2 *pSF, PCUITEMID_CHILD pidl, const SHCOLUMNID *pscid, VARIANT *pVar, BOOL UseFsColMap)
Definition: shlfolder.cpp:133
HRESULT SHELL32_BindToSF(LPCITEMIDLIST pidlRoot, PERSIST_FOLDER_TARGET_INFO *ppfti, LPCITEMIDLIST pidl, const GUID *clsid, REFIID riid, LPVOID *ppvOut)
Definition: shlfolder.cpp:293
#define SHFSF_COL_COMMENT
Definition: shfldr.h:49
static HRESULT MakeSCID(SHCOLUMNID &scid, REFCLSID fmtid, UINT pid)
Definition: shfldr.h:99
#define SHFSF_COL_SIZE
Definition: shfldr.h:45
HRESULT SHELL32_GetDisplayNameOfChild(IShellFolder2 *psf, LPCITEMIDLIST pidl, DWORD dwFlags, LPSTRRET strRet)
Definition: shlfolder.cpp:331
SHCONTF SHELL_GetDefaultFolderEnumSHCONTF()
Definition: shlfolder.cpp:29
#define SHFSF_COL_NAME
Definition: shfldr.h:44
HRESULT SHELL32_CompareChildren(IShellFolder2 *psf, LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
Definition: shlfolder.cpp:349
void AddFSClassKeysToArray(UINT cidl, PCUITEMID_CHILD_ARRAY apidl, HKEY *array, UINT *cKeys)
Definition: shlfolder.cpp:430
HRESULT SHELL_GetDetailsOfAsStringVariant(IShellFolder2 *pSF, PCUITEMID_CHILD pidl, UINT Column, VARIANT *pVar)
Definition: shlfolder.cpp:95
#define SHFSF_COL_TYPE
Definition: shfldr.h:46
LSTATUS AddClassKeyToArray(const WCHAR *szClass, HKEY *array, UINT *cKeys)
Definition: shlfolder.cpp:408
HRESULT SHELL32_CompareDetails(IShellFolder2 *isf, LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
Definition: shlfolder.cpp:372
#define SHFSF_COL_FATTS
Definition: shfldr.h:48
HRESULT Shell_NextElement(_Inout_ LPWSTR *ppch, _Out_ LPWSTR pszOut, _In_ INT cchOut, _In_ BOOL bValidate)
Definition: shlfolder.cpp:155
#define SHFSF_COL_MDATE
Definition: shfldr.h:47
void WINAPI _InsertMenuItemW(HMENU hmenu, UINT indexMenu, BOOL fByPosition, UINT wID, UINT fType, LPCWSTR dwTypeData, UINT fState)
HRESULT hr
Definition: shlfolder.c:183
#define PID_DESCRIPTIONID
Definition: shlguid.h:171
UINT WINAPI Shell_MergeMenus(HMENU hmDst, HMENU hmSrc, UINT uInsert, UINT uIDAdjust, UINT uIDAdjustMax, ULONG uFlags)
Definition: shlmenu.c:856
#define SHDID_FS_DIRECTORY
Definition: shlobj.h:1466
#define SHDID_FS_OTHER
Definition: shlobj.h:1467
#define SSF_SHOWEXTENSIONS
Definition: shlobj.h:1614
#define SHDID_FS_FILE
Definition: shlobj.h:1465
#define MM_ADDSEPARATOR
Definition: shlobj.h:2536
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:1136
#define PathAppend
Definition: shlwapi.h:836
#define IDI_SHELL_EXE
Definition: shresdef.h:581
#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:579
#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:2558
IShellFolder * psf
Definition: shlobj.h:2560
IUnknown * punkAssociationInfo
Definition: shlobj.h:2563
PCUITEMID_CHILD_ARRAY apidl
Definition: shlobj.h:2562
const HKEY * aKeys
Definition: shlobj.h:2565
PCIDLIST_ABSOLUTE pidlFolder
Definition: shlobj.h:2559
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:1398
UINT idCmdLast
Definition: shlobj.h:1401
UINT idCmdFirst
Definition: shlobj.h:1400
UINT indexMenu
Definition: shlobj.h:1399
DWORD dwDescriptionId
Definition: shlobj.h:1488
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:32
WORD uFileDate
Definition: pidl.h:202
WORD uFileAttribs
Definition: pidl.h:204
WORD uFileTime
Definition: pidl.h:203
DWORD dwFileSize
Definition: pidl.h:201
struct tagFileStruct file
Definition: pidl.h:235
union tagPIDLDATA::@596 u
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
INT WINAPI DosDateTimeToVariantTime(USHORT wDosDate, USHORT wDosTime, double *pDateOut)
Definition: variant.c:1211
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:1744
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
_In_ LPCSTR lpName
Definition: winbase.h:2821
_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:281
#define DATE_SHORTDATE
Definition: winnls.h:199
#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:1109
HANDLE WINAPI CopyImage(_In_ HANDLE, _In_ UINT, _In_ int, _In_ int, _In_ UINT)
Definition: cursoricon.c:2275
#define wsprintf
Definition: winuser.h:5893
#define MFS_ENABLED
Definition: winuser.h:761
BOOL WINAPI DestroyMenu(_In_ HMENU)
#define MFT_STRING
Definition: winuser.h:757
#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