ReactOS 0.4.16-dev-1311-g81a4d83
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 // TODO: else if "AlwaysShowExt"
1484
1485 return doHide;
1486}
1487
1489{
1490 /*FIXME: MSDN also mentions SHGDN_FOREDITING which is not yet handled. */
1491 if (!(dwFlags & SHGDN_FORPARSING) &&
1492 ((dwFlags & SHGDN_INFOLDER) || (dwFlags == SHGDN_NORMAL))) {
1493 if (SHELL_FS_HideExtension(szPath) && szPath[0] != '.')
1495 }
1496}
1497
1498/**************************************************************************
1499* CFSFolder::GetDisplayNameOf
1500* Retrieves the display name for the specified file object or subfolder
1501*
1502* PARAMETERS
1503* LPCITEMIDLIST pidl, //[in ] complex pidl to item
1504* DWORD dwFlags, //[in ] SHGNO formatting flags
1505* LPSTRRET lpName) //[out] Returned display name
1506*
1507* FIXME
1508* if the name is in the pidl the ret value should be a STRRET_OFFSET
1509*/
1510
1512 DWORD dwFlags, LPSTRRET strRet)
1513{
1514 if (!strRet)
1515 return E_INVALIDARG;
1516
1517 /* If it is a complex pidl, let the child handle it */
1518 if (!_ILIsPidlSimple (pidl)) /* complex pidl */
1519 {
1520 return SHELL32_GetDisplayNameOfChild(this, pidl, dwFlags, strRet);
1521 }
1522 else if (pidl && !pidl->mkid.cb) /* empty pidl */
1523 {
1524 /* If it is an empty pidl return only the path of the folder */
1528 {
1529 return SHSetStrRet(strRet, m_sPathTarget);
1530 }
1531 return E_INVALIDARG;
1532 }
1533
1534 int len = 0;
1535 LPWSTR pszPath = (LPWSTR)CoTaskMemAlloc((MAX_PATH + 1) * sizeof(WCHAR));
1536 if (!pszPath)
1537 return E_OUTOFMEMORY;
1538
1542 {
1543 lstrcpynW(pszPath, m_sPathTarget, MAX_PATH);
1544 PathAddBackslashW(pszPath);
1545 len = wcslen(pszPath);
1546 }
1547 _ILSimpleGetTextW(pidl, pszPath + len, MAX_PATH + 1 - len);
1549
1550 strRet->uType = STRRET_WSTR;
1551 strRet->pOleStr = pszPath;
1552
1553 TRACE ("-- (%p)->(%s)\n", this, strRet->uType == STRRET_CSTR ? strRet->cStr : debugstr_w(strRet->pOleStr));
1554 return S_OK;
1555}
1556
1557/**************************************************************************
1558* CFSFolder::SetNameOf
1559* Changes the name of a file object or subfolder, possibly changing its item
1560* identifier in the process.
1561*
1562* PARAMETERS
1563* HWND hwndOwner, //[in ] Owner window for output
1564* LPCITEMIDLIST pidl, //[in ] simple pidl of item to change
1565* LPCOLESTR lpszName, //[in ] the items new display name
1566* DWORD dwFlags, //[in ] SHGNO formatting flags
1567* LPITEMIDLIST* ppidlOut) //[out] simple pidl returned
1568*/
1570 HWND hwndOwner,
1571 PCUITEMID_CHILD pidl,
1572 LPCOLESTR lpName,
1573 DWORD dwFlags,
1574 PITEMID_CHILD *pPidlOut)
1575{
1576 WCHAR szSrc[MAX_PATH + 1], szDest[MAX_PATH + 1], szNameBuf[MAX_PATH];
1577 BOOL bIsFolder = ItemIsFolder(ILFindLastID(pidl));
1578
1579 TRACE ("(%p)->(%p,pidl=%p,%s,%u,%p)\n", this, hwndOwner, pidl,
1580 debugstr_w (lpName), dwFlags, pPidlOut);
1581
1582 if (pPidlOut)
1583 *pPidlOut = NULL;
1584
1585 LPCWSTR pszName = GetItemFileName(pidl, szNameBuf, _countof(szNameBuf));
1586 if (!pszName)
1587 {
1588 ERR("Got garbage pidl:\n");
1589 pdump_always(pidl);
1590 return E_INVALIDARG;
1591 }
1592
1593 /* build source path */
1594 PathCombineW(szSrc, m_sPathTarget, pszName);
1595
1596 /* build destination path */
1599 else
1600 lstrcpynW(szDest, lpName, MAX_PATH);
1601
1602 if (!(dwFlags & SHGDN_FORPARSING) && !bIsFolder && SHELL_FS_HideExtension(szSrc))
1603 {
1605 if (*ext)
1606 PathAddExtensionW(szDest, ext);
1607 }
1608
1609 HRESULT hr = S_OK;
1610 TRACE ("src=%s dest=%s\n", debugstr_w(szSrc), debugstr_w(szDest));
1611 if (!wcscmp(szSrc, szDest))
1612 {
1613 /* src and destination is the same */
1614 if (pPidlOut)
1615 hr = SHILClone(pidl, pPidlOut);
1616 }
1617 else
1618 {
1619 hr = SHELL_SingleFileOperation(hwndOwner, FO_RENAME, szSrc, szDest, FOF_SILENT | FOF_ALLOWUNDO, NULL);
1620 if (SUCCEEDED(hr) && pPidlOut)
1621 hr = ParseDisplayName(hwndOwner, NULL, PathFindFileNameW(szDest), NULL, pPidlOut, NULL);
1622 }
1623 return hr;
1624}
1625
1627{
1628 FIXME ("(%p)\n", this);
1629 return E_NOTIMPL;
1630}
1631
1633{
1634 FIXME ("(%p)\n", this);
1635 return E_NOTIMPL;
1636}
1637
1639 ULONG * pSort, ULONG * pDisplay)
1640{
1641 TRACE ("(%p)\n", this);
1642
1643 if (pSort)
1644 *pSort = 0;
1645 if (pDisplay)
1646 *pDisplay = 0;
1647
1648 return S_OK;
1649}
1650
1652 SHCOLSTATEF *pcsFlags)
1653{
1654 TRACE ("(%p)\n", this);
1655
1656 if (!pcsFlags)
1657 return E_INVALIDARG;
1658 else
1659 return GetDefaultFSColumnState(iColumn, *pcsFlags);
1660}
1661
1663{
1664 if (!_ILGetFSType(pidl))
1665 return E_INVALIDARG;
1666 HRESULT hr;
1667 if (pscid->fmtid == FMTID_ShellDetails)
1668 {
1669 switch (pscid->pid)
1670 {
1671 case PID_DESCRIPTIONID:
1672 {
1674 return hr;
1675 SHDESCRIPTIONID *pDID = (SHDESCRIPTIONID*)V_ARRAY(pv)->pvData;
1676 if (ItemIsFolder(pidl))
1678 else if (_ILGetFSType(pidl) & PT_FS_FILE_FLAG)
1680 else
1682 if (FAILED(GetItemCLSID(pidl, &pDID->clsid)))
1683 pDID->clsid = CLSID_NULL;
1684 return S_OK;
1685 }
1686 }
1687 }
1688 // Handle non-string fields here when possible instead of deferring to GetDetailsOf
1689 const FileStruct &fsitem = ((PIDLDATA*)pidl->mkid.abID)->u.file;
1690 if (pscid->fmtid == FMTID_Storage)
1691 {
1692 switch (pscid->pid)
1693 {
1694 case PID_STG_NAME: // Handled directly here for faster performance
1695 return SHELL_GetDetailsOfAsStringVariant(this, pidl, SHFSF_COL_NAME, pv);
1696 case PID_STG_SIZE:
1697 V_VT(pv) = VT_UI4;
1698 V_UI4(pv) = _ILGetFileSize(pidl, NULL, 0);
1699 return S_OK;
1700 case PID_STG_ATTRIBUTES:
1701 V_VT(pv) = VT_UI4;
1702 V_UI4(pv) = fsitem.uFileAttribs;
1703 return S_OK;
1704 case PID_STG_WRITETIME:
1705 V_VT(pv) = VT_DATE;
1706 if (DosDateTimeToVariantTime(fsitem.uFileDate, fsitem.uFileTime, &V_DATE(pv)))
1707 return S_OK;
1708 break;
1709 }
1710 }
1711 return SH32_GetDetailsOfPKeyAsVariant(this, pidl, pscid, pv, TRUE);
1712}
1713
1715 UINT iColumn, SHELLDETAILS * psd)
1716{
1717 HRESULT hr = E_FAIL;
1718
1719 TRACE ("(%p)->(%p %i %p)\n", this, pidl, iColumn, psd);
1720
1721 if (!psd || iColumn >= GENERICSHELLVIEWCOLUMNS)
1722 return E_INVALIDARG;
1723
1724 if (!pidl)
1725 {
1726 /* the header titles */
1727 return GetFSColumnDetails(iColumn, *psd);
1728 }
1729 else
1730 {
1731 FILETIME ft;
1732 hr = S_OK;
1733 psd->str.uType = STRRET_WSTR;
1734 if (iColumn != SHFSF_COL_NAME)
1735 {
1736 psd->str.pOleStr = (LPWSTR)CoTaskMemAlloc(MAX_PATH * sizeof(WCHAR));
1737 if (!psd->str.pOleStr)
1738 return E_OUTOFMEMORY;
1739 }
1740 /* the data from the pidl */
1741 switch (iColumn)
1742 {
1743 case SHFSF_COL_NAME:
1745 break;
1746 case SHFSF_COL_SIZE:
1747 _ILGetFileSize(pidl, psd->str.pOleStr, MAX_PATH);
1748 break;
1749 case SHFSF_COL_TYPE:
1751 break;
1752 case SHFSF_COL_MDATE:
1753 if (!_ILGetFileDateTime(pidl, &ft) || FAILED(FormatDateTime(ft, psd->str.pOleStr, MAX_PATH)))
1754 {
1755 *psd->str.pOleStr = UNICODE_NULL;
1756 hr = S_FALSE;
1757 }
1758 break;
1759 case SHFSF_COL_FATTS:
1761 break;
1762 case SHFSF_COL_COMMENT:
1763 psd->str.pOleStr[0] = UNICODE_NULL; // TODO: Extract comment from .lnk files? desktop.ini?
1764 break;
1765#if DBG
1766 default:
1767 ERR("Missing case for column %d\n", iColumn);
1768#else
1770#endif
1771 }
1772 }
1773
1774 return hr;
1775}
1776
1778{
1779 switch (column)
1780 {
1781 case SHFSF_COL_NAME: return MakeSCID(*pscid, FMTID_Storage, PID_STG_NAME);
1782 case SHFSF_COL_SIZE: return MakeSCID(*pscid, FMTID_Storage, PID_STG_SIZE);
1783 case SHFSF_COL_TYPE: return MakeSCID(*pscid, FMTID_Storage, PID_STG_STORAGETYPE);
1784 case SHFSF_COL_MDATE: return MakeSCID(*pscid, FMTID_Storage, PID_STG_WRITETIME);
1785 case SHFSF_COL_FATTS: return MakeSCID(*pscid, FMTID_Storage, PID_STG_ATTRIBUTES);
1786 case SHFSF_COL_COMMENT: return MakeSCID(*pscid, FMTID_SummaryInformation, PIDSI_COMMENTS);
1787 }
1788 return E_INVALIDARG;
1789}
1790
1791/************************************************************************
1792 * CFSFolder::GetClassID
1793 */
1795{
1796 TRACE ("(%p)\n", this);
1797
1798 if (!lpClassId)
1799 return E_POINTER;
1800
1801 *lpClassId = *m_pclsid;
1802
1803 return S_OK;
1804}
1805
1806/************************************************************************
1807 * CFSFolder::Initialize
1808 *
1809 * NOTES
1810 * m_sPathTarget is not set. Don't know how to handle in a non rooted environment.
1811 */
1813{
1814 WCHAR wszTemp[MAX_PATH];
1815
1816 TRACE ("(%p)->(%p)\n", this, pidl);
1817
1818 SHFree(m_pidlRoot); /* free the old pidl */
1819 m_pidlRoot = ILClone (pidl); /* set my pidl */
1820
1823
1824 /* set my path */
1825 HRESULT hr = E_FAIL;
1826 if (SHGetPathFromIDListW (pidl, wszTemp))
1827 hr = SHStrDupW(wszTemp, &m_sPathTarget);
1828
1829 TRACE ("--(%p)->(%s)\n", this, debugstr_w(m_sPathTarget));
1830 return hr;
1831}
1832
1833/**************************************************************************
1834 * CFSFolder::GetCurFolder
1835 */
1837{
1838 TRACE ("(%p)->(%p)\n", this, pidl);
1839
1840 if (!pidl)
1841 return E_POINTER;
1842
1843 *pidl = ILClone(m_pidlRoot);
1844 return S_OK;
1845}
1846
1847/**************************************************************************
1848 * CFSFolder::InitializeEx
1849 *
1850 * FIXME: error handling
1851 */
1853 const PERSIST_FOLDER_TARGET_INFO * ppfti)
1854{
1855 WCHAR wszTemp[MAX_PATH];
1856
1857 TRACE("(%p)->(%p,%p,%p)\n", this, pbc, pidlRootx, ppfti);
1858 if (ppfti)
1859 TRACE("--%p %s %s 0x%08x 0x%08x\n",
1861 debugstr_w (ppfti->szNetworkProvider), ppfti->dwAttributes,
1862 ppfti->csidl);
1863
1864 pdump (pidlRootx);
1865 if (ppfti && ppfti->pidlTargetFolder)
1866 pdump(ppfti->pidlTargetFolder);
1867
1868 if (m_pidlRoot)
1869 __SHFreeAndNil(&m_pidlRoot); /* free the old */
1870 if (m_sPathTarget)
1872
1873 /*
1874 * Root path and pidl
1875 */
1876 m_pidlRoot = ILClone(pidlRootx);
1877
1878 /*
1879 * the target folder is spezified in csidl OR pidlTargetFolder OR
1880 * szTargetParsingName
1881 */
1882 HRESULT hr = E_FAIL;
1883 if (ppfti)
1884 {
1885 if (ppfti->csidl != -1)
1886 {
1888 if (SHGetSpecialFolderPathW(0, wszTemp, ppfti->csidl, create))
1889 hr = SHStrDupW(wszTemp, &m_sPathTarget);
1890 }
1891 else if (ppfti->szTargetParsingName[0])
1892 {
1894 }
1895 else if (ppfti->pidlTargetFolder)
1896 {
1897 if (SHGetPathFromIDListW(ppfti->pidlTargetFolder, wszTemp))
1898 hr = SHStrDupW(wszTemp, &m_sPathTarget);
1899 }
1900 }
1901 TRACE("--(%p)->(target=%s)\n", this, debugstr_w(m_sPathTarget));
1903 return hr;
1904}
1905
1907{
1908 FIXME("(%p)->(%p)\n", this, ppfti);
1909 ZeroMemory(ppfti, sizeof (*ppfti));
1910 return E_NOTIMPL;
1911}
1912
1914{
1916
1917 sprintfW(buf, L"ShellEx\\{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
1918 riid.Data1, riid.Data2, riid.Data3,
1919 riid.Data4[0], riid.Data4[1], riid.Data4[2], riid.Data4[3],
1920 riid.Data4[4], riid.Data4[5], riid.Data4[6], riid.Data4[7]);
1921
1922 CLSID clsid;
1923 HRESULT hr;
1924
1925 hr = GetCLSIDForFileType(pidl, buf, &clsid);
1926 if (hr != S_OK)
1927 return hr;
1928
1929 hr = _CreateShellExtInstance(&clsid, pidl, riid, ppvOut);
1931 return hr;
1932
1933 return S_OK;
1934}
1935
1937{
1938 HRESULT hr;
1939
1940 TRACE("CFSFolder::_GetDropTarget entered\n");
1941
1942 if (_ILIsFolder (pidl))
1943 {
1944 CComPtr<IShellFolder> psfChild;
1945 hr = this->BindToObject(pidl, NULL, IID_PPV_ARG(IShellFolder, &psfChild));
1947 return hr;
1948
1949 return psfChild->CreateViewObject(NULL, IID_IDropTarget, ppvOut);
1950 }
1951
1952 CLSID clsid;
1953 hr = GetCLSIDForFileType(pidl, L"shellex\\DropHandler", &clsid);
1954 if (hr != S_OK)
1955 return hr;
1956
1957 hr = _CreateShellExtInstance(&clsid, pidl, IID_IDropTarget, ppvOut);
1959 return S_FALSE;
1960
1961 return S_OK;
1962}
1963
1965{
1966 CLSID clsid;
1967 HRESULT hr;
1968
1969 hr = GetCLSIDForFileType(pidl, L"shellex\\IconHandler", &clsid);
1970 if (hr != S_OK)
1971 return hr;
1972
1973 hr = _CreateShellExtInstance(&clsid, pidl, riid, ppvOut);
1975 return S_FALSE;
1976
1977 return S_OK;
1978}
1979
1981{
1982 HRESULT hr;
1983 WCHAR wszPath[MAX_PATH], szNameBuf[MAX_PATH];
1984
1985 LPCWSTR pszName = GetItemFileName(pidl, szNameBuf, _countof(szNameBuf));
1986 if (!pszName)
1987 {
1988 ERR("Got garbage pidl\n");
1989 pdump_always(pidl);
1990 return E_INVALIDARG;
1991 }
1992 PathCombineW(wszPath, m_sPathTarget, pszName);
1993
1994 CComPtr<IPersistFile> pp;
1997 return hr;
1998
1999 pp->Load(wszPath, 0);
2000
2001 hr = pp->QueryInterface(riid, ppvOut);
2002 if (hr != S_OK)
2003 {
2004 ERR("Failed to query for interface IID_IShellExtInit hr %x pclsid %s\n", hr, wine_dbgstr_guid(pclsid));
2005 return hr;
2006 }
2007 return hr;
2008}
2009
2011{
2012 enum { IDC_PROPERTIES };
2013 /* no data object means no selection */
2014 if (!pdtobj)
2015 {
2016 if (uMsg == DFM_INVOKECOMMAND && wParam == IDC_PROPERTIES)
2017 {
2019 }
2020 else if (uMsg == DFM_MERGECONTEXTMENU)
2021 {
2022 QCMINFO *pqcminfo = (QCMINFO *)lParam;
2023 HMENU hpopup = CreatePopupMenu();
2025 pqcminfo->idCmdFirst = Shell_MergeMenus(pqcminfo->hmenu, hpopup, pqcminfo->indexMenu, pqcminfo->idCmdFirst, pqcminfo->idCmdLast, MM_ADDSEPARATOR);
2026 DestroyMenu(hpopup);
2027 return S_OK;
2028 }
2029 }
2030 return SHELL32_DefaultContextMenuCallBack(psf, pdtobj, uMsg);
2031}
2032
2034{
2035 // create stream from file
2036 HRESULT hr;
2037 CComPtr<IStream> pStream;
2039 FALSE, NULL, &pStream);
2040 if (FAILED(hr))
2041 return NULL;
2042
2043 // load the picture
2044 HBITMAP hbm = NULL;
2045 CComPtr<IPicture> pPicture;
2046 OleLoadPicture(pStream, 0, FALSE, IID_IPicture, (LPVOID *)&pPicture);
2047
2048 // get the bitmap handle
2049 if (pPicture)
2050 {
2051 pPicture->get_Handle((OLE_HANDLE *)&hbm);
2052
2053 // copy the bitmap handle
2055 }
2056
2057 return hbm;
2058}
2059
2061{
2062 if (data == NULL)
2063 {
2064 return E_POINTER;
2065 }
2066 if (data->cbSize != sizeof(*data))
2067 {
2068 // NOTE: You have to set the cbData member before SFVM_GET_CUSTOMVIEWINFO call.
2069 return E_INVALIDARG;
2070 }
2071
2072 data->hbmBack = NULL;
2073 data->clrText = CLR_INVALID;
2074 data->clrTextBack = CLR_INVALID;
2075
2077
2078 // does the folder exists?
2080 {
2081 return E_INVALIDARG;
2082 }
2083
2084 // don't use custom view in network path for security
2086 {
2087 return E_ACCESSDENIED;
2088 }
2089
2090 // build the ini file path
2092 PathAppend(szIniFile, L"desktop.ini");
2093
2094 static LPCWSTR TheGUID = L"{BE098140-A513-11D0-A3A4-00C04FD706EC}";
2095 static LPCWSTR Space = L" \t\n\r\f\v";
2096
2097 // get info from ini file
2098 WCHAR szImage[MAX_PATH], szText[64];
2099
2100 // load the image
2101 szImage[0] = UNICODE_NULL;
2102 GetPrivateProfileStringW(TheGUID, L"IconArea_Image", L"", szImage, _countof(szImage), szIniFile);
2103 if (szImage[0])
2104 {
2105 StrTrimW(szImage, Space);
2106 if (PathIsRelativeW(szImage))
2107 {
2108 PathAppendW(szPath, szImage);
2109 StringCchCopyW(szImage, _countof(szImage), szPath);
2110 }
2111 data->hbmBack = DoLoadPicture(szImage);
2112 }
2113
2114 // load the text color
2115 szText[0] = UNICODE_NULL;
2116 GetPrivateProfileStringW(TheGUID, L"IconArea_Text", L"", szText, _countof(szText), szIniFile);
2117 if (szText[0])
2118 {
2119 StrTrimW(szText, Space);
2120
2121 LPWSTR pchEnd = NULL;
2122 COLORREF cr = (wcstol(szText, &pchEnd, 0) & 0xFFFFFF);
2123
2124 if (pchEnd && !*pchEnd)
2125 data->clrText = cr;
2126 }
2127
2128 // load the text background color
2129 szText[0] = UNICODE_NULL;
2130 GetPrivateProfileStringW(TheGUID, L"IconArea_TextBackground", L"", szText, _countof(szText), szIniFile);
2131 if (szText[0])
2132 {
2133 StrTrimW(szText, Space);
2134
2135 LPWSTR pchEnd = NULL;
2136 COLORREF cr = (wcstol(szText, &pchEnd, 0) & 0xFFFFFF);
2137
2138 if (pchEnd && !*pchEnd)
2139 data->clrTextBack = cr;
2140 }
2141
2142 if (data->hbmBack != NULL || data->clrText != CLR_INVALID || data->clrTextBack != CLR_INVALID)
2143 return S_OK;
2144
2145 return E_FAIL;
2146}
2147
2149{
2151 switch (uMsg)
2152 {
2155 break;
2156 case SFVM_GETCOMMANDDIR:
2157 if (m_sPathTarget)
2159 break;
2160 }
2161 return hr;
2162}
2163
2165{
2166 FILETIME lft;
2168 FileTimeToLocalFileTime(&ft, &lft);
2169 FileTimeToSystemTime(&lft, &time);
2171 if (ret > 0 && ret < cchBuf)
2172 {
2173 /* Append space + time without seconds */
2174 Buf[ret-1] = ' ';
2176 }
2177 return ret ? S_OK : E_FAIL;
2178}
2179
2181{
2182 if (StrFormatKBSizeW(size, Buf, cchBuf))
2183 return S_OK;
2184 if (cchBuf)
2185 *Buf = UNICODE_NULL;
2186 return E_FAIL;
2187}
HRESULT WINAPI SHCreateShellFolderView(const SFV_CREATE *pcsfv, IShellView **ppsv)
Definition: CDefView.cpp:4800
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:1511
STDMETHOD() CallBack(IShellFolder *psf, HWND hwndOwner, IDataObject *pdtobj, UINT uMsg, WPARAM wParam, LPARAM lParam) override
Definition: CFSFolder.cpp:2010
STDMETHOD() Initialize(PCIDLIST_ABSOLUTE pidl) override
Definition: CFSFolder.cpp:1812
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:1980
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:1569
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:2180
HRESULT _GetIconHandler(LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppvOut)
Definition: CFSFolder.cpp:1964
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:1836
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:1936
HRESULT _CreateIDListFromName(LPCWSTR pszName, DWORD attrs, IBindCtx *pbc, LPITEMIDLIST *ppidl)
Definition: CFSFolder.cpp:829
STDMETHOD() MapColumnToSCID(UINT column, SHCOLUMNID *pscid) override
Definition: CFSFolder.cpp:1777
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:1852
STDMETHOD() GetDefaultColumnState(UINT iColumn, DWORD *pcsFlags) override
Definition: CFSFolder.cpp:1651
HRESULT WINAPI GetCustomViewInfo(ULONG unknown, SFVM_CUSTOMVIEWINFO_DATA *data)
Definition: CFSFolder.cpp:2060
STDMETHOD() MessageSFVCB(UINT uMsg, WPARAM wParam, LPARAM lParam) override
Definition: CFSFolder.cpp:2148
LPITEMIDLIST m_pidlRoot
Definition: CFSFolder.h:29
static HRESULT FormatDateTime(const FILETIME &ft, LPWSTR Buf, UINT cchBuf)
Definition: CFSFolder.cpp:2164
STDMETHOD() GetFolderTargetInfo(PERSIST_FOLDER_TARGET_INFO *ppfti) override
Definition: CFSFolder.cpp:1906
STDMETHOD() GetDetailsEx(PCUITEMID_CHILD pidl, const SHCOLUMNID *pscid, VARIANT *pv) override
Definition: CFSFolder.cpp:1662
STDMETHOD() EnumSearches(IEnumExtraSearch **ppenum) override
Definition: CFSFolder.cpp:1632
STDMETHOD() GetDefaultSearchGUID(GUID *pguid) override
Definition: CFSFolder.cpp:1626
STDMETHOD() GetClassID(CLSID *lpClassId) override
Definition: CFSFolder.cpp:1794
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:1638
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:1913
STDMETHOD() GetDetailsOf(PCUITEMID_CHILD pidl, UINT iColumn, SHELLDETAILS *psd) override
Definition: CFSFolder.cpp:1714
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
void WINAPI PathRemoveExtensionW(WCHAR *path)
Definition: path.c:1889
void WINAPI PathUnquoteSpacesW(WCHAR *path)
Definition: path.c:1949
WCHAR *WINAPI PathFindFileNameW(const WCHAR *path)
Definition: path.c:1644
LPWSTR WINAPI PathFindExtensionW(const WCHAR *path)
Definition: path.c:1217
BOOL WINAPI PathIsRelativeW(const WCHAR *path)
Definition: path.c:973
int WINAPI PathParseIconLocationW(WCHAR *path)
Definition: path.c:2587
BOOL WINAPI PathFileExistsW(const WCHAR *path)
Definition: path.c:2550
BOOL WINAPI StrTrimW(WCHAR *str, const WCHAR *trim)
Definition: string.c:796
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:1488
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:2033
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:337
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
BOOL WINAPI PathIsDirectoryW(LPCWSTR lpszPath)
Definition: path.c:1729
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
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:199
#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:238
void WINAPI ILFree(LPITEMIDLIST pidl)
Definition: pidl.c:1045
DWORD _ILGetFileAttributes(LPCITEMIDLIST pidl, LPWSTR pOut, UINT uOutSize)
Definition: pidl.c:2579
LPITEMIDLIST WINAPI ILFindLastID(LPCITEMIDLIST pidl)
Definition: pidl.c:199
LPPIDLDATA _ILGetDataPointer(LPCITEMIDLIST pidl)
Definition: pidl.c:2272
HRESULT WINAPI SHBindToParent(LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppv, LPCITEMIDLIST *ppidlLast)
Definition: pidl.c:1498
FileStructW * _ILGetFileStructW(LPCITEMIDLIST pidl)
Definition: pidl.c:2444
BOOL _ILIsFolder(LPCITEMIDLIST pidl)
Definition: pidl.c:2138
BOOL WINAPI SHGetPathFromIDListW(LPCITEMIDLIST pidl, LPWSTR pszPath)
Definition: pidl.c:1490
LPITEMIDLIST WINAPI ILGetNext(LPCITEMIDLIST pidl)
Definition: pidl.c:971
BOOL ILGetDisplayNameExW(LPSHELLFOLDER psf, LPCITEMIDLIST pidl, LPWSTR path, DWORD type)
Definition: pidl.c:101
BOOL _ILGetFileDateTime(LPCITEMIDLIST pidl, FILETIME *pFt)
Definition: pidl.c:2486
DWORD _ILGetFileSize(LPCITEMIDLIST pidl, LPWSTR pOut, UINT uOutSize)
Definition: pidl.c:2513
BOOL _ILIsValue(LPCITEMIDLIST pidl)
Definition: pidl.c:2145
BOOL _ILIsDrive(LPCITEMIDLIST pidl)
Definition: pidl.c:2131
BOOL _ILGetExtension(LPCITEMIDLIST pidl, LPWSTR pOut, UINT uOutSize)
Definition: pidl.c:2532
DWORD _ILSimpleGetTextW(LPCITEMIDLIST pidl, LPWSTR szOut, UINT uOutSize)
Definition: pidl.c:2192
LPITEMIDLIST _ILCreateFromFindDataW(const WIN32_FIND_DATAW *wfd)
Definition: pidl.c:1934
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:165
static HRESULT SHELL_CreateVariantBuffer(VARIANT *pVar, UINT cb)
Definition: shell32_main.h:238
DWORD WINAPI ParseFieldW(LPCWSTR src, DWORD nField, LPWSTR dst, DWORD len) DECLSPEC_HIDDEN
Definition: shellord.c:117
#define FO_RENAME
Definition: shellapi.h:139
#define FOF_ALLOWUNDO
Definition: shellapi.h:147
#define FOF_SILENT
Definition: shellapi.h:143
#define CSIDL_FLAG_CREATE
#define STATUS_SUCCESS
Definition: shellext.h:65
#define MAKE_COMPARE_HRESULT(x)
Definition: shellutils.h:660
#define SHELL_GetSetting(pss, ssf, field)
Definition: shellutils.h:884
#define S_EQUAL
Definition: shellutils.h:658
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:1144
#define PathAppend
Definition: shlwapi.h:836
#define IDI_SHELL_EXE
Definition: shresdef.h:588
#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:586
#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::@624 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:74
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:1753
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
_In_ LPCSTR lpName
Definition: winbase.h:2830
_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:296
#define DATE_SHORTDATE
Definition: winnls.h:209
#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:5950
#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