[SHELL] IPersistFolder::Initialize takes a PCIDLIST_ABSOLUTE. CORE-16385
[reactos.git] / dll / win32 / shell32 / shellmenu / CMergedFolder.cpp
1 /*
2 * Shell Menu Site
3 *
4 * Copyright 2014 David Quintana
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20 #include "shellmenu.h"
21 #include <atlwin.h>
22 #include <shlwapi_undoc.h>
23
24 #include "CMergedFolder.h"
25
26 WINE_DEFAULT_DEBUG_CHANNEL(CMergedFolder);
27
28 struct LocalPidlInfo
29 {
30 BOOL shared;
31 IShellFolder * parent;
32 LPITEMIDLIST pidl;
33 LPITEMIDLIST pidl2;
34 LPCWSTR parseName;
35 };
36
37 class CEnumMergedFolder :
38 public CComObjectRootEx<CComMultiThreadModelNoCS>,
39 public IEnumIDList
40 {
41
42 private:
43 CComPtr<IShellFolder> m_UserLocalFolder;
44 CComPtr<IShellFolder> m_AllUSersFolder;
45
46 HWND m_HwndOwner;
47 SHCONTF m_Flags;
48
49 HDSA m_hDsa;
50 UINT m_hDsaIndex;
51 UINT m_hDsaCount;
52
53 public:
54 CEnumMergedFolder();
55 virtual ~CEnumMergedFolder();
56
57 DECLARE_NOT_AGGREGATABLE(CEnumMergedFolder)
58 DECLARE_PROTECT_FINAL_CONSTRUCT()
59
60 BEGIN_COM_MAP(CEnumMergedFolder)
61 COM_INTERFACE_ENTRY_IID(IID_IEnumIDList, IEnumIDList)
62 END_COM_MAP()
63
64 int DsaDeleteCallback(LocalPidlInfo * info);
65
66 static int CALLBACK s_DsaDeleteCallback(void *pItem, void *pData);
67
68 HRESULT SetSources(IShellFolder * userLocal, IShellFolder * allUSers);
69 HRESULT Begin(HWND hwndOwner, SHCONTF flags);
70 HRESULT FindPidlInList(HWND hwndOwner, LPCITEMIDLIST pcidl, LocalPidlInfo * pinfo);
71 HRESULT FindByName(HWND hwndOwner, LPCWSTR strParsingName, LocalPidlInfo * pinfo);
72
73 virtual HRESULT STDMETHODCALLTYPE Next(
74 ULONG celt,
75 LPITEMIDLIST *rgelt,
76 ULONG *pceltFetched);
77
78 virtual HRESULT STDMETHODCALLTYPE Skip(ULONG celt);
79 virtual HRESULT STDMETHODCALLTYPE Reset();
80 virtual HRESULT STDMETHODCALLTYPE Clone(IEnumIDList **ppenum);
81 };
82
83 CEnumMergedFolder::CEnumMergedFolder() :
84 m_UserLocalFolder(NULL),
85 m_AllUSersFolder(NULL),
86 m_HwndOwner(NULL),
87 m_Flags(0),
88 m_hDsa(NULL),
89 m_hDsaIndex(0),
90 m_hDsaCount(0)
91 {
92 }
93
94 CEnumMergedFolder::~CEnumMergedFolder()
95 {
96 DSA_DestroyCallback(m_hDsa, s_DsaDeleteCallback, this);
97 }
98
99 int CEnumMergedFolder::DsaDeleteCallback(LocalPidlInfo * info)
100 {
101 ILFree(info->pidl);
102 if (info->pidl2)
103 ILFree(info->pidl2);
104 CoTaskMemFree((LPVOID)info->parseName);
105 return 0;
106 }
107
108 int CALLBACK CEnumMergedFolder::s_DsaDeleteCallback(void *pItem, void *pData)
109 {
110 CEnumMergedFolder * mf = (CEnumMergedFolder*) pData;
111 LocalPidlInfo * item = (LocalPidlInfo*) pItem;
112 return mf->DsaDeleteCallback(item);
113 }
114
115 HRESULT CEnumMergedFolder::SetSources(IShellFolder * userLocal, IShellFolder * allUSers)
116 {
117 m_UserLocalFolder = userLocal;
118 m_AllUSersFolder = allUSers;
119
120 TRACE("SetSources %p %p\n", userLocal, allUSers);
121 return S_OK;
122 }
123
124 HRESULT CEnumMergedFolder::Begin(HWND hwndOwner, SHCONTF flags)
125 {
126 HRESULT hr;
127 LPITEMIDLIST pidl = NULL;
128
129 if (m_hDsa && m_HwndOwner == hwndOwner && m_Flags == flags)
130 {
131 return Reset();
132 }
133
134 TRACE("Search conditions changed, recreating list...\n");
135
136 CComPtr<IEnumIDList> userLocal;
137 CComPtr<IEnumIDList> allUsers;
138
139 hr = m_UserLocalFolder->EnumObjects(hwndOwner, flags, &userLocal);
140 if (FAILED_UNEXPECTEDLY(hr))
141 return hr;
142 hr = m_AllUSersFolder->EnumObjects(hwndOwner, flags, &allUsers);
143 if (FAILED_UNEXPECTEDLY(hr))
144 return hr;
145
146 if (!m_hDsa)
147 {
148 m_hDsa = DSA_Create(sizeof(LocalPidlInfo), 10);
149 }
150
151 DSA_EnumCallback(m_hDsa, s_DsaDeleteCallback, this);
152 DSA_DeleteAllItems(m_hDsa);
153 m_hDsaCount = 0;
154
155 // The sources are not ordered so load all of the items for the user folder first
156 TRACE("Loading Local entries...\n");
157 for (;;)
158 {
159 hr = userLocal->Next(1, &pidl, NULL);
160 if (FAILED_UNEXPECTEDLY(hr))
161 return hr;
162
163 if (hr == S_FALSE)
164 break;
165
166 LPWSTR name;
167 STRRET str = { STRRET_WSTR };
168 hr = m_UserLocalFolder->GetDisplayNameOf(pidl, SHGDN_FORPARSING | SHGDN_INFOLDER, &str);
169 if (FAILED(hr))
170 return hr;
171 StrRetToStrW(&str, pidl, &name);
172
173 LocalPidlInfo info = {
174 FALSE,
175 m_UserLocalFolder,
176 ILClone(pidl),
177 NULL,
178 name
179 };
180
181 ILFree(pidl);
182
183 TRACE("Inserting item %d with name %S\n", m_hDsaCount, name);
184 int idx = DSA_InsertItem(m_hDsa, DSA_APPEND, &info);
185 TRACE("New index: %d\n", idx);
186
187 m_hDsaCount++;
188 }
189
190 // Then load the items for the common folder
191 TRACE("Loading Common entries...\n");
192 for (;;)
193 {
194 hr = allUsers->Next(1, &pidl, NULL);
195 if (FAILED_UNEXPECTEDLY(hr))
196 return hr;
197
198 if (hr == S_FALSE)
199 break;
200
201 LPWSTR name;
202 STRRET str = { STRRET_WSTR };
203 hr = m_AllUSersFolder->GetDisplayNameOf(pidl, SHGDN_FORPARSING | SHGDN_INFOLDER, &str);
204 if (FAILED(hr))
205 return hr;
206 StrRetToStrW(&str, pidl, &name);
207
208 LocalPidlInfo info = {
209 FALSE,
210 m_AllUSersFolder,
211 ILClone(pidl),
212 NULL,
213 name
214 };
215
216 ILFree(pidl);
217
218 // Try to find an existing entry with the same name, and makr it as shared.
219 // FIXME: This is sub-optimal, a hash table would be a lot more efficient.
220 BOOL bShared = FALSE;
221 for (int i = 0; i < (int)m_hDsaCount; i++)
222 {
223 LocalPidlInfo *pInfo = (LocalPidlInfo *) DSA_GetItemPtr(m_hDsa, i);
224
225 int order = CompareStringW(GetThreadLocale(), NORM_IGNORECASE,
226 pInfo->parseName, lstrlenW(pInfo->parseName),
227 info.parseName, lstrlenW(info.parseName));
228
229 if (order == CSTR_EQUAL)
230 {
231 TRACE("Item name already exists! Marking '%S' as shared ...\n", name);
232 bShared = TRUE;
233 pInfo->shared = TRUE;
234 pInfo->pidl2 = info.pidl;
235 CoTaskMemFree(name);
236 break;
237 }
238 }
239
240 // If an entry was not found, add a new one for this item
241 if (!bShared)
242 {
243 TRACE("Inserting item %d with name %S\n", m_hDsaCount, name);
244 int idx = DSA_InsertItem(m_hDsa, DSA_APPEND, &info);
245 TRACE("New index: %d\n", idx);
246
247 m_hDsaCount++;
248 }
249 }
250
251 m_HwndOwner = hwndOwner;
252 m_Flags = flags;
253
254 return Reset();
255 }
256
257 HRESULT CEnumMergedFolder::FindPidlInList(HWND hwndOwner, LPCITEMIDLIST pcidl, LocalPidlInfo * pinfo)
258 {
259 HRESULT hr;
260
261 if (!m_hDsa)
262 {
263 Begin(hwndOwner, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS);
264 }
265
266 TRACE("Searching for pidl { cb=%d } in a list of %d items\n", pcidl->mkid.cb, m_hDsaCount);
267
268 for (int i = 0; i < (int)m_hDsaCount; i++)
269 {
270 LocalPidlInfo * pInfo = (LocalPidlInfo *) DSA_GetItemPtr(m_hDsa, i);
271 if (!pInfo)
272 return E_FAIL;
273
274 TRACE("Comparing with item at %d with parent %p and pidl { cb=%d }\n", i, pInfo->parent, pInfo->pidl->mkid.cb);
275
276 hr = pInfo->parent->CompareIDs(0, pInfo->pidl, pcidl);
277 if (FAILED_UNEXPECTEDLY(hr))
278 return hr;
279
280 if (hr == S_OK)
281 {
282 *pinfo = *pInfo;
283 return S_OK;
284 }
285 else
286 {
287 TRACE("Comparison returned %d\n", (int) (short) (hr & 0xFFFF));
288 }
289 }
290
291 TRACE("Pidl not found\n");
292 return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
293 }
294
295 HRESULT CEnumMergedFolder::FindByName(HWND hwndOwner, LPCWSTR strParsingName, LocalPidlInfo * pinfo)
296 {
297 if (!m_hDsa)
298 {
299 Begin(hwndOwner, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS);
300 }
301
302 TRACE("Searching for '%S' in a list of %d items\n", strParsingName, m_hDsaCount);
303
304 for (int i = 0; i < (int) m_hDsaCount; i++)
305 {
306 LocalPidlInfo * pInfo = (LocalPidlInfo *) DSA_GetItemPtr(m_hDsa, i);
307 if (!pInfo)
308 return E_FAIL;
309
310 int order = CompareStringW(GetThreadLocale(), NORM_IGNORECASE,
311 pInfo->parseName, lstrlenW(pInfo->parseName),
312 strParsingName, lstrlenW(strParsingName));
313 switch (order)
314 {
315 case CSTR_EQUAL:
316 *pinfo = *pInfo;
317 return S_OK;
318 default:
319 continue;
320 }
321 }
322
323 TRACE("Pidl not found\n");
324 return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
325 }
326
327 HRESULT STDMETHODCALLTYPE CEnumMergedFolder::Next(
328 ULONG celt,
329 LPITEMIDLIST *rgelt,
330 ULONG *pceltFetched)
331 {
332 if (pceltFetched)
333 *pceltFetched = 0;
334
335 if (m_hDsaIndex == m_hDsaCount)
336 return S_FALSE;
337
338 for (int i = 0; i < (int)celt;)
339 {
340 LocalPidlInfo * tinfo = (LocalPidlInfo *) DSA_GetItemPtr(m_hDsa, m_hDsaIndex);
341 if (!tinfo)
342 return E_FAIL;
343
344 LocalPidlInfo info = *tinfo;
345
346 TRACE("Returning next item at %d with parent %p and pidl { cb=%d }\n", m_hDsaIndex, info.parent, info.pidl->mkid.cb);
347
348 // FIXME: ILClone shouldn't be needed here! This should be causing leaks
349 if (rgelt) rgelt[i] = ILClone(info.pidl);
350 i++;
351
352 m_hDsaIndex++;
353 if (m_hDsaIndex == m_hDsaCount)
354 {
355 if (pceltFetched)
356 *pceltFetched = i;
357 return (i == (int)celt) ? S_OK : S_FALSE;
358 }
359 }
360
361 if (pceltFetched) *pceltFetched = celt;
362 return S_OK;
363 }
364
365 HRESULT STDMETHODCALLTYPE CEnumMergedFolder::Skip(ULONG celt)
366 {
367 return Next(celt, NULL, NULL);
368 }
369
370 HRESULT STDMETHODCALLTYPE CEnumMergedFolder::Reset()
371 {
372 m_hDsaIndex = 0;
373 return S_OK;
374 }
375
376 HRESULT STDMETHODCALLTYPE CEnumMergedFolder::Clone(
377 IEnumIDList **ppenum)
378 {
379 UNIMPLEMENTED;
380 return E_NOTIMPL;
381 }
382
383 //-----------------------------------------------------------------------------
384 // CMergedFolder
385
386 CMergedFolder::CMergedFolder() :
387 m_UserLocal(NULL),
388 m_AllUsers(NULL),
389 m_EnumSource(NULL),
390 m_UserLocalPidl(NULL),
391 m_AllUsersPidl(NULL),
392 m_shellPidl(NULL)
393 {
394 }
395
396 CMergedFolder::~CMergedFolder()
397 {
398 if (m_UserLocalPidl) ILFree(m_UserLocalPidl);
399 if (m_AllUsersPidl) ILFree(m_AllUsersPidl);
400 }
401
402 // IAugmentedShellFolder2
403 HRESULT STDMETHODCALLTYPE CMergedFolder::AddNameSpace(LPGUID lpGuid, IShellFolder * psf, LPCITEMIDLIST pcidl, ULONG dwUnknown)
404 {
405 if (lpGuid)
406 {
407 TRACE("FIXME: No idea how to handle the GUID\n");
408 return E_NOTIMPL;
409 }
410
411 TRACE("AddNameSpace %p %p\n", m_UserLocal.p, m_AllUsers.p);
412
413 // FIXME: Use a DSA to store the list of merged namespaces, together with their related info (psf, pidl, ...)
414 // For now, assume only 2 will ever be used, and ignore all the other data.
415 if (!m_UserLocal)
416 {
417 m_UserLocal = psf;
418 m_UserLocalPidl = ILClone(pcidl);
419 return S_OK;
420 }
421
422 if (m_AllUsers)
423 return E_FAIL;
424
425 m_AllUsers = psf;
426 m_AllUsersPidl = ILClone(pcidl);
427
428 m_EnumSource = new CComObject<CEnumMergedFolder>();
429 return m_EnumSource->SetSources(m_UserLocal, m_AllUsers);
430 }
431
432 HRESULT STDMETHODCALLTYPE CMergedFolder::GetNameSpaceID(LPCITEMIDLIST pcidl, LPGUID lpGuid)
433 {
434 UNIMPLEMENTED;
435 return E_NOTIMPL;
436 }
437
438 HRESULT STDMETHODCALLTYPE CMergedFolder::QueryNameSpace(ULONG dwUnknown, LPGUID lpGuid, IShellFolder ** ppsf)
439 {
440 UNIMPLEMENTED;
441 return E_NOTIMPL;
442 }
443
444 HRESULT STDMETHODCALLTYPE CMergedFolder::EnumNameSpace(ULONG dwUnknown, PULONG lpUnknown)
445 {
446 UNIMPLEMENTED;
447 return E_NOTIMPL;
448 }
449
450 HRESULT STDMETHODCALLTYPE CMergedFolder::UnWrapIDList(LPCITEMIDLIST pcidl, LONG lUnknown, IShellFolder ** ppsf, LPITEMIDLIST * ppidl1, LPITEMIDLIST *ppidl2, LONG * lpUnknown)
451 {
452 UNIMPLEMENTED;
453 return E_NOTIMPL;
454 }
455
456 // IShellFolder
457 HRESULT STDMETHODCALLTYPE CMergedFolder::ParseDisplayName(
458 HWND hwndOwner,
459 LPBC pbcReserved,
460 LPOLESTR lpszDisplayName,
461 ULONG *pchEaten,
462 LPITEMIDLIST *ppidl,
463 ULONG *pdwAttributes)
464 {
465 HRESULT hr;
466 LocalPidlInfo info;
467
468 if (!ppidl)
469 return E_FAIL;
470
471 if (pchEaten)
472 *pchEaten = 0;
473
474 if (pdwAttributes)
475 *pdwAttributes = 0;
476
477 TRACE("ParseDisplayName name=%S\n", lpszDisplayName);
478
479 hr = m_EnumSource->FindByName(hwndOwner, lpszDisplayName, &info);
480 if (FAILED(hr))
481 {
482 return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
483 }
484
485 *ppidl = ILClone(info.pidl);
486
487 if (pchEaten)
488 *pchEaten = lstrlenW(info.parseName);
489
490 if (pdwAttributes)
491 *pdwAttributes = info.parent->GetAttributesOf(1, (LPCITEMIDLIST*)ppidl, pdwAttributes);
492
493 return S_OK;
494 }
495
496 HRESULT STDMETHODCALLTYPE CMergedFolder::EnumObjects(
497 HWND hwndOwner,
498 SHCONTF grfFlags,
499 IEnumIDList **ppenumIDList)
500 {
501 TRACE("EnumObjects\n");
502 HRESULT hr = m_EnumSource->QueryInterface(IID_PPV_ARG(IEnumIDList, ppenumIDList));
503 if (FAILED_UNEXPECTEDLY(hr))
504 return hr;
505 return m_EnumSource->Begin(hwndOwner, grfFlags);
506 }
507
508 HRESULT STDMETHODCALLTYPE CMergedFolder::BindToObject(
509 LPCITEMIDLIST pidl,
510 LPBC pbcReserved,
511 REFIID riid,
512 void **ppvOut)
513 {
514 LocalPidlInfo info;
515 HRESULT hr;
516
517 hr = m_EnumSource->FindPidlInList(NULL, pidl, &info);
518 if (FAILED_UNEXPECTEDLY(hr))
519 return hr;
520
521 TRACE("BindToObject shared = %d\n", info.shared);
522
523 if (!info.shared)
524 return info.parent->BindToObject(info.pidl, pbcReserved, riid, ppvOut);
525
526 if (riid != IID_IShellFolder)
527 return E_FAIL;
528
529 // Construct a child MergedFolder and return it
530 CComPtr<IShellFolder> fld1;
531 CComPtr<IShellFolder> fld2;
532
533 // In shared folders, the user one takes precedence over the common one, so it will always be on pidl1
534 hr = m_UserLocal->BindToObject(info.pidl, pbcReserved, IID_PPV_ARG(IShellFolder, &fld1));
535 if (FAILED_UNEXPECTEDLY(hr))
536 return hr;
537
538 hr = m_AllUsers->BindToObject(info.pidl2, pbcReserved, IID_PPV_ARG(IShellFolder, &fld2));
539 if (FAILED_UNEXPECTEDLY(hr))
540 return hr;
541
542 CComPtr<IAugmentedShellFolder> pasf;
543 hr = CMergedFolder_CreateInstance(IID_PPV_ARG(IAugmentedShellFolder, &pasf));
544 if (FAILED_UNEXPECTEDLY(hr))
545 return hr;
546
547 hr = pasf->QueryInterface(riid, ppvOut);
548 if (FAILED_UNEXPECTEDLY(hr))
549 return hr;
550
551 hr = pasf->AddNameSpace(NULL, fld1, info.pidl, 0xFF00);
552 if (FAILED_UNEXPECTEDLY(hr))
553 return hr;
554
555 hr = pasf->AddNameSpace(NULL, fld2, info.pidl2, 0x0000);
556 if (FAILED_UNEXPECTEDLY(hr))
557 return hr;
558
559 return hr;
560 }
561
562 HRESULT STDMETHODCALLTYPE CMergedFolder::BindToStorage(
563 LPCITEMIDLIST pidl,
564 LPBC pbcReserved,
565 REFIID riid,
566 void **ppvObj)
567 {
568 UNIMPLEMENTED;
569 return E_NOTIMPL;
570 }
571
572 HRESULT STDMETHODCALLTYPE CMergedFolder::CompareIDs(
573 LPARAM lParam,
574 LPCITEMIDLIST pidl1,
575 LPCITEMIDLIST pidl2)
576 {
577 TRACE("CompareIDs\n");
578 return m_UserLocal->CompareIDs(lParam, pidl1, pidl2);
579 }
580
581 HRESULT STDMETHODCALLTYPE CMergedFolder::CreateViewObject(
582 HWND hwndOwner,
583 REFIID riid,
584 void **ppvOut)
585 {
586 UNIMPLEMENTED;
587 return E_NOTIMPL;
588 }
589
590 HRESULT STDMETHODCALLTYPE CMergedFolder::GetAttributesOf(
591 UINT cidl,
592 PCUITEMID_CHILD_ARRAY apidl,
593 SFGAOF *rgfInOut)
594 {
595 LocalPidlInfo info;
596 HRESULT hr;
597
598 TRACE("GetAttributesOf\n");
599
600 for (int i = 0; i < (int)cidl; i++)
601 {
602 LPCITEMIDLIST pidl = apidl[i];
603
604 hr = m_EnumSource->FindPidlInList(NULL, pidl, &info);
605 if (FAILED_UNEXPECTEDLY(hr))
606 return hr;
607
608 pidl = info.pidl;
609
610 SFGAOF * pinOut1 = rgfInOut ? rgfInOut + i : NULL;
611
612 hr = info.parent->GetAttributesOf(1, &pidl, pinOut1);
613
614 if (FAILED_UNEXPECTEDLY(hr))
615 return hr;
616 }
617
618 return S_OK;
619 }
620
621 HRESULT STDMETHODCALLTYPE CMergedFolder::GetUIObjectOf(
622 HWND hwndOwner,
623 UINT cidl,
624 PCUITEMID_CHILD_ARRAY apidl,
625 REFIID riid,
626 UINT *prgfInOut,
627 void **ppvOut)
628 {
629 LocalPidlInfo info;
630 HRESULT hr;
631
632 TRACE("GetUIObjectOf\n");
633
634 for (int i = 0; i < (int)cidl; i++)
635 {
636 LPCITEMIDLIST pidl = apidl[i];
637
638 TRACE("Processing GetUIObjectOf item %d of %u...\n", i, cidl);
639
640 hr = m_EnumSource->FindPidlInList(hwndOwner, pidl, &info);
641 if (FAILED_UNEXPECTEDLY(hr))
642 return hr;
643
644 pidl = info.pidl;
645
646 TRACE("FindPidlInList succeeded with parent %p and pidl { db=%d }\n", info.parent, info.pidl->mkid.cb);
647
648 UINT * pinOut1 = prgfInOut ? prgfInOut+i : NULL;
649 void** ppvOut1 = ppvOut ? ppvOut + i : NULL;
650
651 hr = info.parent->GetUIObjectOf(hwndOwner, 1, &pidl, riid, pinOut1, ppvOut1);
652
653 if (FAILED_UNEXPECTEDLY(hr))
654 return hr;
655 }
656
657 return S_OK;
658 }
659
660 HRESULT STDMETHODCALLTYPE CMergedFolder::GetDisplayNameOf(
661 LPCITEMIDLIST pidl,
662 SHGDNF uFlags,
663 STRRET *lpName)
664 {
665 LocalPidlInfo info;
666 HRESULT hr;
667
668 TRACE("GetDisplayNameOf\n");
669
670 hr = m_EnumSource->FindPidlInList(NULL, pidl, &info);
671 if (FAILED_UNEXPECTEDLY(hr))
672 return hr;
673
674 hr = info.parent->GetDisplayNameOf(info.pidl, uFlags, lpName);
675
676 if (FAILED_UNEXPECTEDLY(hr))
677 return hr;
678 return S_OK;
679 }
680
681 HRESULT STDMETHODCALLTYPE CMergedFolder::SetNameOf(
682 HWND hwnd,
683 LPCITEMIDLIST pidl,
684 LPCOLESTR lpszName,
685 SHGDNF uFlags,
686 LPITEMIDLIST *ppidlOut)
687 {
688 UNIMPLEMENTED;
689 return E_NOTIMPL;
690 }
691
692 // IPersist
693 HRESULT STDMETHODCALLTYPE CMergedFolder::GetClassID(CLSID *lpClassId)
694 {
695 UNIMPLEMENTED;
696 return E_NOTIMPL;
697 }
698
699 // IPersistFolder
700 HRESULT STDMETHODCALLTYPE CMergedFolder::Initialize(PCIDLIST_ABSOLUTE pidl)
701 {
702 m_shellPidl = ILClone(pidl);
703 return S_OK;
704 }
705
706 // IPersistFolder2
707 HRESULT STDMETHODCALLTYPE CMergedFolder::GetCurFolder(PIDLIST_ABSOLUTE * pidl)
708 {
709 if (pidl)
710 *pidl = m_shellPidl;
711 return S_OK;
712 }
713
714 // IShellFolder2
715 HRESULT STDMETHODCALLTYPE CMergedFolder::GetDefaultSearchGUID(
716 GUID *lpguid)
717 {
718 UNIMPLEMENTED;
719 return E_NOTIMPL;
720 }
721
722 HRESULT STDMETHODCALLTYPE CMergedFolder::EnumSearches(
723 IEnumExtraSearch **ppenum)
724 {
725 UNIMPLEMENTED;
726 return E_NOTIMPL;
727 }
728
729 HRESULT STDMETHODCALLTYPE CMergedFolder::GetDefaultColumn(
730 DWORD dwReserved,
731 ULONG *pSort,
732 ULONG *pDisplay)
733 {
734 UNIMPLEMENTED;
735 return E_NOTIMPL;
736 }
737
738 HRESULT STDMETHODCALLTYPE CMergedFolder::GetDefaultColumnState(
739 UINT iColumn,
740 SHCOLSTATEF *pcsFlags)
741 {
742 UNIMPLEMENTED;
743 return E_NOTIMPL;
744 }
745
746 HRESULT STDMETHODCALLTYPE CMergedFolder::GetDetailsEx(
747 LPCITEMIDLIST pidl,
748 const SHCOLUMNID *pscid,
749 VARIANT *pv)
750 {
751 LocalPidlInfo info;
752 HRESULT hr;
753
754 TRACE("GetDetailsEx\n");
755
756 hr = m_EnumSource->FindPidlInList(NULL, pidl, &info);
757 if (FAILED_UNEXPECTEDLY(hr))
758 return hr;
759
760 CComPtr<IShellFolder2> parent2;
761 hr = info.parent->QueryInterface(IID_PPV_ARG(IShellFolder2, &parent2));
762 if (FAILED_UNEXPECTEDLY(hr))
763 return hr;
764
765 hr = parent2->GetDetailsEx(info.pidl, pscid, pv);
766 if (FAILED_UNEXPECTEDLY(hr))
767 return hr;
768 return S_OK;
769 }
770
771 HRESULT STDMETHODCALLTYPE CMergedFolder::GetDetailsOf(
772 LPCITEMIDLIST pidl,
773 UINT iColumn,
774 SHELLDETAILS *psd)
775 {
776 LocalPidlInfo info;
777 HRESULT hr;
778
779 TRACE("GetDetailsOf\n");
780
781 hr = m_EnumSource->FindPidlInList(NULL, pidl, &info);
782 if (FAILED_UNEXPECTEDLY(hr))
783 return hr;
784
785 CComPtr<IShellFolder2> parent2;
786 hr = info.parent->QueryInterface(IID_PPV_ARG(IShellFolder2, &parent2));
787 if (FAILED_UNEXPECTEDLY(hr))
788 return hr;
789
790 hr = parent2->GetDetailsOf(info.pidl, iColumn, psd);
791
792 if (FAILED_UNEXPECTEDLY(hr))
793 return hr;
794 return S_OK;
795 }
796
797 HRESULT STDMETHODCALLTYPE CMergedFolder::MapColumnToSCID(
798 UINT iColumn,
799 SHCOLUMNID *pscid)
800 {
801 UNIMPLEMENTED;
802 return E_NOTIMPL;
803 }
804
805 // IAugmentedShellFolder3
806 HRESULT STDMETHODCALLTYPE CMergedFolder::QueryNameSpace2(ULONG, QUERYNAMESPACEINFO *)
807 {
808 UNIMPLEMENTED;
809 return E_NOTIMPL;
810 }
811
812 extern "C"
813 HRESULT WINAPI RSHELL_CMergedFolder_CreateInstance(REFIID riid, LPVOID *ppv)
814 {
815 return ShellObjectCreator<CMergedFolder>(riid, ppv);
816 }