ReactOS  0.4.13-dev-52-g0efcfec
explorerband.cpp
Go to the documentation of this file.
1 /*
2  * ReactOS Explorer
3  *
4  * Copyright 2016 Sylvain Deverre <deverre dot sylv at gmail dot com>
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19  */
20 
21 #include "precomp.h"
22 #include <commoncontrols.h>
23 #include <undocshell.h>
24 
25 #if 1
26 #undef UNIMPLEMENTED
27 
28 #define UNIMPLEMENTED DbgPrint("%s is UNIMPLEMENTED!\n", __FUNCTION__)
29 #endif
30 
31 /*
32  * TODO:
33  * - Monitor correctly "external" shell interrupts (seems like we need to register/deregister them for each folder)
34  * - find and fix what cause explorer crashes sometimes (seems to be explorer that does more releases than addref)
35  * - TESTING
36  */
37 
38 typedef struct _PIDLDATA
39 {
41  BYTE data[1];
43 
44 #define PT_GUID 0x1F
45 #define PT_SHELLEXT 0x2E
46 #define PT_YAGUID 0x70
47 
49 {
50  LPPIDLDATA lpPData = (LPPIDLDATA)&pidl->mkid.abID;
51 
52  return (pidl &&
53  ((lpPData && (PT_GUID == lpPData->type || PT_SHELLEXT== lpPData->type ||
54  PT_YAGUID == lpPData->type)) || (pidl && pidl->mkid.cb == 0x00)));
55 }
56 
58 {
59  IShellFolder *pShellFolder = NULL;
60  LPCITEMIDLIST pidlRelative = NULL;
61  STRRET str;
62  HRESULT hr;
63 
64  if (pidlDirectory == NULL || szDisplayName == NULL)
65  {
66  return E_FAIL;
67  }
68 
69  hr = SHBindToParent(pidlDirectory, IID_PPV_ARG(IShellFolder, &pShellFolder), &pidlRelative);
70 
71  if (SUCCEEDED(hr))
72  {
73  hr = pShellFolder->GetDisplayNameOf(pidlRelative,uFlags,&str);
74  if (SUCCEEDED(hr))
75  {
76  hr = StrRetToBuf(&str,pidlDirectory,szDisplayName,cchMax);
77  }
78  pShellFolder->Release();
79  }
80  return hr;
81 }
82 
83 /*
84  This is a Windows hack, because shell event messages in Windows gives an
85  ill-formed PIDL stripped from useful data that parses incorrectly with SHGetFileInfo.
86  So we need to re-enumerate subfolders until we find one with the same name.
87  */
89 {
90  HRESULT hr;
93  CComPtr<IEnumIDList> pEnumIDList;
94  LPITEMIDLIST childPidl;
95  LPITEMIDLIST correctChild;
96  LPITEMIDLIST correctParent;
97  ULONG fetched;
98  DWORD EnumFlags;
99 
100 
101  EnumFlags = SHCONTF_FOLDERS | SHCONTF_INCLUDEHIDDEN;
102  hr = SHBindToParent(buggyPidl, IID_PPV_ARG(IShellFolder, &folder), (LPCITEMIDLIST*)&childPidl);
103  *cleanPidl = NULL;
104  if (!SUCCEEDED(hr))
105  {
106  ERR("Can't bind to parent folder\n");
107  return hr;
108  }
109  hr = folder->QueryInterface(IID_PPV_ARG(IPersistFolder2, &persist));
110  if (!SUCCEEDED(hr))
111  {
112  ERR("PIDL doesn't belong to the shell namespace, aborting\n");
113  return hr;
114  }
115 
116  hr = persist->GetCurFolder(&correctParent);
117  if (!SUCCEEDED(hr))
118  {
119  ERR("Unable to get current folder\n");
120  return hr;
121  }
122 
123  hr = folder->EnumObjects(NULL,EnumFlags,&pEnumIDList);
124  // avoid broken IShellFolder implementations that return null pointer with success
125  if (!SUCCEEDED(hr) || !pEnumIDList)
126  {
127  ERR("Can't enum the folder !\n");
128  return hr;
129  }
130 
131  while(SUCCEEDED(pEnumIDList->Next(1, &correctChild, &fetched)) && correctChild && fetched)
132  {
133  if (!folder->CompareIDs(0, childPidl, correctChild))
134  {
135  *cleanPidl = ILCombine(correctParent, correctChild);
136  ILFree(correctChild);
137  goto Cleanup;
138  }
139  ILFree(correctChild);
140  }
141 Cleanup:
142  ILFree(correctParent);
143  return hr;
144 }
145 
147  pSite(NULL), fVisible(FALSE), bNavigating(FALSE), dwBandID(0), pidlCurrent(NULL)
148 {
149 }
150 
152 {
153  if(pidlCurrent)
154  {
156  }
157 }
158 
160 {
161  // Init the treeview here
162  HRESULT hr;
163  LPITEMIDLIST pidl;
164  CComPtr<IWebBrowser2> browserService;
165  SHChangeNotifyEntry shcne;
166 
168  if (FAILED_UNEXPECTEDLY(hr))
169  return;
170 
171  hr = SHGetFolderLocation(m_hWnd, CSIDL_DESKTOP, NULL, 0, &pidl);
172  if (FAILED_UNEXPECTEDLY(hr))
173  return;
174 
175  IImageList * piml;
177  if (FAILED_UNEXPECTEDLY(hr))
178  return;
179 
181 
182  // Insert the root node
183  hRoot = InsertItem(0, pDesktop, pidl, pidl, FALSE);
184  if (!hRoot)
185  {
186  ERR("Failed to create root item\n");
187  return;
188  }
189 
190  NodeInfo* pNodeInfo = GetNodeInfo(hRoot);
191 
192  // Insert child nodes
193  InsertSubitems(hRoot, pNodeInfo);
194  TreeView_Expand(m_hWnd, hRoot, TVE_EXPAND);
195 
196  // Navigate to current folder position
198 
199  // Register shell notification
200  shcne.pidl = pidl;
201  shcne.fRecursive = TRUE;
203  m_hWnd,
207  1,
208  &shcne);
209  if (!shellRegID)
210  {
211  ERR("Something went wrong, error %08x\n", GetLastError());
212  }
213  // Register browser connection endpoint
214  hr = IUnknown_QueryService(pSite, SID_SWebBrowserApp, IID_PPV_ARG(IWebBrowser2, &browserService));
215  if (FAILED_UNEXPECTEDLY(hr))
216  return;
217 
218  hr = AtlAdvise(browserService, dynamic_cast<IDispatch*>(this), DIID_DWebBrowserEvents, &adviseCookie);
219  if (FAILED_UNEXPECTEDLY(hr))
220  return;
221 
222  ILFree(pidl);
223 }
224 
226 {
227  HRESULT hr;
228  CComPtr <IWebBrowser2> browserService;
229 
230  TRACE("Cleaning up explorer band ...\n");
231 
232  hr = IUnknown_QueryService(pSite, SID_SWebBrowserApp, IID_PPV_ARG(IWebBrowser2, &browserService));
233  if (FAILED_UNEXPECTEDLY(hr))
234  return;
235 
236  hr = AtlUnadvise(browserService, DIID_DWebBrowserEvents, adviseCookie);
237  /* Remove all items of the treeview */
238  RevokeDragDrop(m_hWnd);
239  TreeView_DeleteAllItems(m_hWnd);
240  pDesktop = NULL;
241  hRoot = NULL;
242  TRACE("Cleanup done !\n");
243 }
244 
246 {
247  TVITEM tvItem;
248 
249  tvItem.mask = TVIF_PARAM;
250  tvItem.hItem = hItem;
251 
252  if (!TreeView_GetItem(m_hWnd, &tvItem))
253  return 0;
254 
255  return reinterpret_cast<NodeInfo*>(tvItem.lParam);
256 }
257 
259 {
260  CComPtr<IOleWindow> pBrowserOleWnd;
261  CMINVOKECOMMANDINFO cmi;
262  HWND browserWnd;
263  HRESULT hr;
264 
266  if (FAILED_UNEXPECTEDLY(hr))
267  return hr;
268 
269  hr = pBrowserOleWnd->GetWindow(&browserWnd);
270  if (FAILED_UNEXPECTEDLY(hr))
271  return hr;
272 
273  ZeroMemory(&cmi, sizeof(cmi));
274  cmi.cbSize = sizeof(cmi);
275  cmi.lpVerb = MAKEINTRESOURCEA(nCmd);
276  cmi.hwnd = browserWnd;
277  if (GetKeyState(VK_SHIFT) & 0x8000)
278  cmi.fMask |= CMIC_MASK_SHIFT_DOWN;
279  if (GetKeyState(VK_CONTROL) & 0x8000)
280  cmi.fMask |= CMIC_MASK_CONTROL_DOWN;
281 
282  return menu->InvokeCommand(&cmi);
283 }
284 
286 {
287  CComPtr<IShellBrowser> pBrowserService;
288  HRESULT hr;
289 
290  hr = IUnknown_QueryService(pSite, SID_STopLevelBrowser, IID_PPV_ARG(IShellBrowser, &pBrowserService));
291  if (FAILED_UNEXPECTEDLY(hr))
292  return hr;
293 
294  hr = pBrowserService->BrowseObject(pidlGoto, SBSP_SAMEBROWSER | SBSP_ABSOLUTE);
295  if (FAILED_UNEXPECTEDLY(hr))
296  return hr;
297 
298  if(pidlCurrent)
299  {
301  pidlCurrent = ILClone(pidlGoto);
302  }
303  return hr;
304 }
305 
306 // *** notifications handling ***
308 {
309  NodeInfo *pNodeInfo;
310 
311  if (pnmtv->action == TVE_COLLAPSE) {
312  if (pnmtv->itemNew.hItem == hRoot)
313  {
314  // Prenvent root from collapsing
315  pnmtv->itemNew.mask |= TVIF_STATE;
316  pnmtv->itemNew.stateMask |= TVIS_EXPANDED;
317  pnmtv->itemNew.state &= ~TVIS_EXPANDED;
318  pnmtv->action = TVE_EXPAND;
319  return TRUE;
320  }
321  }
322  if (pnmtv->action == TVE_EXPAND) {
323  // Grab our directory PIDL
324  pNodeInfo = GetNodeInfo(pnmtv->itemNew.hItem);
325  // We have it, let's try
326  if (pNodeInfo && !pNodeInfo->expanded)
327  if (!InsertSubitems(pnmtv->itemNew.hItem, pNodeInfo)) {
328  // remove subitem "+" since we failed to add subitems
329  TV_ITEM tvItem;
330 
331  tvItem.mask = TVIF_CHILDREN;
332  tvItem.hItem = pnmtv->itemNew.hItem;
333  tvItem.cChildren = 0;
334 
335  TreeView_SetItem(m_hWnd, &tvItem);
336  }
337  }
338  return FALSE;
339 }
340 
342 {
343  /* Destroy memory associated to our node */
344  NodeInfo* ptr = GetNodeInfo(pnmtv->itemNew.hItem);
345  if (ptr)
346  {
347  ILFree(ptr->relativePidl);
348  ILFree(ptr->absolutePidl);
349  delete ptr;
350  }
351  return TRUE;
352 }
353 
355 {
356  NodeInfo* pNodeInfo = GetNodeInfo(pnmtv->itemNew.hItem);
357 
358  /* Prevents navigation if selection is initiated inside the band */
359  if (bNavigating)
360  return;
361 
362  UpdateBrowser(pNodeInfo->absolutePidl);
363 
364  SetFocus();
365  // Expand the node
366  //TreeView_Expand(m_hWnd, pnmtv->itemNew.hItem, TVE_EXPAND);
367 }
368 
370 {
371  CComPtr<IShellFolder> pSrcFolder;
373  LPCITEMIDLIST pLast;
374  HRESULT hr;
375  DWORD dwEffect;
376  DWORD dwEffect2;
377 
378  dwEffect = DROPEFFECT_COPY | DROPEFFECT_MOVE;
379  if (!pnmtv->itemNew.lParam)
380  return;
381  NodeInfo* pNodeInfo = GetNodeInfo(pnmtv->itemNew.hItem);
382  hr = SHBindToParent(pNodeInfo->absolutePidl, IID_PPV_ARG(IShellFolder, &pSrcFolder), &pLast);
383  if (!SUCCEEDED(hr))
384  return;
385  hr = pSrcFolder->GetUIObjectOf(m_hWnd, 1, &pLast, IID_IDataObject, 0, reinterpret_cast<void**>(&pObj));
386  if (!SUCCEEDED(hr))
387  return;
388  DoDragDrop(pObj, this, dwEffect, &dwEffect2);
389  return;
390 }
391 
392 
393 // *** ATL event handlers ***
395 {
396  HTREEITEM item;
397  NodeInfo *info;
398  HMENU treeMenu;
399  WORD x;
400  WORD y;
401  CComPtr<IShellFolder> pFolder;
402  CComPtr<IContextMenu> contextMenu;
403  HRESULT hr;
404  UINT uCommand;
405  LPITEMIDLIST pidlChild;
406 
407  treeMenu = NULL;
408  item = TreeView_GetSelection(m_hWnd);
409  bHandled = TRUE;
410  if (!item)
411  {
412  goto Cleanup;
413  }
414 
415  x = LOWORD(lParam);
416  y = HIWORD(lParam);
417  if (x == -1 && y == -1)
418  {
419  // TODO: grab position of tree item and position it correctly
420  }
421 
422  info = GetNodeInfo(item);
423  if (!info)
424  {
425  ERR("No node data, something has gone wrong !\n");
426  goto Cleanup;
427  }
428  hr = SHBindToParent(info->absolutePidl, IID_PPV_ARG(IShellFolder, &pFolder),
429  (LPCITEMIDLIST*)&pidlChild);
430  if (!SUCCEEDED(hr))
431  {
432  ERR("Can't bind to folder!\n");
433  goto Cleanup;
434  }
435  hr = pFolder->GetUIObjectOf(m_hWnd, 1, (LPCITEMIDLIST*)&pidlChild, IID_IContextMenu,
436  NULL, reinterpret_cast<void**>(&contextMenu));
437  if (!SUCCEEDED(hr))
438  {
439  ERR("Can't get IContextMenu interface\n");
440  goto Cleanup;
441  }
442 
443  IUnknown_SetSite(contextMenu, (IDeskBand *)this);
444 
445  treeMenu = CreatePopupMenu();
446  hr = contextMenu->QueryContextMenu(treeMenu, 0, FCIDM_SHVIEWFIRST, FCIDM_SHVIEWLAST,
447  CMF_EXPLORE);
448  if (!SUCCEEDED(hr))
449  {
450  WARN("Can't get context menu for item\n");
451  DestroyMenu(treeMenu);
452  goto Cleanup;
453  }
455  x, y, 0, m_hWnd, NULL);
456 
457  ExecuteCommand(contextMenu, uCommand);
458 
459 Cleanup:
460  if (contextMenu)
461  IUnknown_SetSite(contextMenu, NULL);
462  if (treeMenu)
463  DestroyMenu(treeMenu);
464  bNavigating = TRUE;
466  bNavigating = FALSE;
467  return TRUE;
468 }
469 
471 {
472  bHandled = FALSE;
473  if (uMsg == WM_RBUTTONDOWN)
474  {
476  info.pt.x = LOWORD(lParam);
477  info.pt.y = HIWORD(lParam);
478  info.flags = TVHT_ONITEM;
479  info.hItem = NULL;
480 
481  // Save the current location
483 
484  // Move to the item selected by the treeview (don't change right pane)
485  TreeView_HitTest(m_hWnd, &info);
486  bNavigating = TRUE;
487  TreeView_SelectItem(m_hWnd, info.hItem);
488  bNavigating = FALSE;
489  }
490  return FALSE; /* let the wndproc process the message */
491 }
492 
494 {
496  LPITEMIDLIST clean;
497  HTREEITEM pItem;
498 
500  /* TODO: handle shell notifications */
501  switch(lParam & ~SHCNE_INTERRUPT)
502  {
503  case SHCNE_MKDIR:
504  if (!SUCCEEDED(_ReparsePIDL(dest[0], &clean)))
505  {
506  ERR("Can't reparse PIDL to a valid one\n");
507  return FALSE;
508  }
509  NavigateToPIDL(clean, &pItem, FALSE, TRUE, FALSE);
510  ILFree(clean);
511  break;
512  case SHCNE_RMDIR:
513  DeleteItem(dest[0]);
514  break;
515  case SHCNE_RENAMEFOLDER:
516  if (!SUCCEEDED(_ReparsePIDL(dest[1], &clean)))
517  {
518  ERR("Can't reparse PIDL to a valid one\n");
519  return FALSE;
520  }
521  if (NavigateToPIDL(dest[0], &pItem, FALSE, FALSE, FALSE))
522  RenameItem(pItem, clean);
523  ILFree(clean);
524  break;
525  case SHCNE_UPDATEDIR:
526  // We don't take care of this message
527  TRACE("Directory updated\n");
528  break;
529  default:
530  TRACE("Unhandled message\n");
531  }
532  return TRUE;
533 }
534 
536 {
537  bFocused = TRUE;
538  IUnknown_OnFocusChangeIS(pSite, reinterpret_cast<IUnknown*>(this), TRUE);
539  bHandled = FALSE;
540  return TRUE;
541 }
542 
544 {
545  IUnknown_OnFocusChangeIS(pSite, reinterpret_cast<IUnknown*>(this), FALSE);
546  bHandled = FALSE;
547  return TRUE;
548 }
549 
550 // *** Helper functions ***
552 {
553  TV_INSERTSTRUCT tvInsert;
554  HTREEITEM htiCreated;
555 
556  /* Get the attributes of the node */
557  SFGAOF attrs = SFGAO_STREAM | SFGAO_HASSUBFOLDER;
558  HRESULT hr = psfParent->GetAttributesOf(1, &pEltRelative, &attrs);
559  if (FAILED_UNEXPECTEDLY(hr))
560  return NULL;
561 
562  /* Ignore streams */
563  if ((attrs & SFGAO_STREAM))
564  {
565  TRACE("Ignoring stream\n");
566  return NULL;
567  }
568 
569  /* Get the name of the node */
570  WCHAR wszDisplayName[MAX_PATH];
571  STRRET strret;
572  hr = psfParent->GetDisplayNameOf(pEltRelative, SHGDN_INFOLDER, &strret);
573  if (FAILED_UNEXPECTEDLY(hr))
574  return NULL;
575 
576  hr = StrRetToBufW(&strret, pEltRelative, wszDisplayName, MAX_PATH);
577  if (FAILED_UNEXPECTEDLY(hr))
578  return NULL;
579 
580  /* Get the icon of the node */
581  INT iIcon = SHMapPIDLToSystemImageListIndex(psfParent, pEltRelative, NULL);
582 
583  NodeInfo* pChildInfo = new NodeInfo;
584  if (!pChildInfo)
585  {
586  ERR("Failed to allocate NodeInfo\n");
587  return FALSE;
588  }
589 
590  // Store our node info
591  pChildInfo->absolutePidl = ILClone(pElt);
592  pChildInfo->relativePidl = ILClone(pEltRelative);
593  pChildInfo->expanded = FALSE;
594 
595  // Set up our treeview template
596  tvInsert.hParent = hParent;
597  tvInsert.hInsertAfter = TVI_LAST;
598  tvInsert.item.mask = TVIF_PARAM | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_CHILDREN;
599  tvInsert.item.cchTextMax = MAX_PATH;
600  tvInsert.item.pszText = wszDisplayName;
601  tvInsert.item.iImage = tvInsert.item.iSelectedImage = iIcon;
602  tvInsert.item.cChildren = (attrs & SFGAO_HASSUBFOLDER) ? 1 : 0;
603  tvInsert.item.lParam = (LPARAM)pChildInfo;
604 
605  htiCreated = TreeView_InsertItem(m_hWnd, &tvInsert);
606 
607  if (bSort)
608  {
609  TVSORTCB sortCallback;
610  sortCallback.hParent = hParent;
611  sortCallback.lpfnCompare = CompareTreeItems;
612  sortCallback.lParam = (LPARAM)this;
613  SendMessage(TVM_SORTCHILDRENCB, 0, (LPARAM)&sortCallback);
614  }
615 
616  return htiCreated;
617 }
618 
619 /* This is the slow version of the above method */
621 {
622  CComPtr<IShellFolder> psfFolder;
623  HRESULT hr = SHBindToParent(pElt, IID_PPV_ARG(IShellFolder, &psfFolder), NULL);
624  if (FAILED_UNEXPECTEDLY(hr))
625  return NULL;
626 
627  return InsertItem(hParent, psfFolder, pElt, pEltRelative, bSort);
628 }
629 
631 {
632  CComPtr<IEnumIDList> pEnumIDList;
633  LPITEMIDLIST pidlSub;
635  SHCONTF EnumFlags;
636  HRESULT hr;
637  ULONG fetched;
638  ULONG uItemCount;
639  CComPtr<IShellFolder> pFolder;
640  TVSORTCB sortCallback;
641 
642  entry = pNodeInfo->absolutePidl;
643  fetched = 1;
644  uItemCount = 0;
645  EnumFlags = SHCONTF_FOLDERS;
646 
647  hr = SHGetFolderLocation(m_hWnd, CSIDL_DESKTOP, NULL, 0, &pidlSub);
648  if (!SUCCEEDED(hr))
649  {
650  ERR("Can't get desktop PIDL !\n");
651  return FALSE;
652  }
653 
654  if (!pDesktop->CompareIDs(NULL, pidlSub, entry))
655  {
656  // We are the desktop, so use pDesktop as pFolder
657  pFolder = pDesktop;
658  }
659  else
660  {
661  // Get an IShellFolder of our pidl
662  hr = pDesktop->BindToObject(entry, NULL, IID_PPV_ARG(IShellFolder, &pFolder));
663  if (!SUCCEEDED(hr))
664  {
665  ILFree(pidlSub);
666  ERR("Can't bind folder to desktop !\n");
667  return FALSE;
668  }
669  }
670  ILFree(pidlSub);
671 
672  // TODO: handle hidden folders according to settings !
673  EnumFlags |= SHCONTF_INCLUDEHIDDEN;
674 
675  // Enum through objects
676  hr = pFolder->EnumObjects(NULL,EnumFlags,&pEnumIDList);
677 
678  // avoid broken IShellFolder implementations that return null pointer with success
679  if (!SUCCEEDED(hr) || !pEnumIDList)
680  {
681  ERR("Can't enum the folder !\n");
682  return FALSE;
683  }
684 
685  /* Don't redraw while we add stuff into the tree */
687  while(SUCCEEDED(pEnumIDList->Next(1, &pidlSub, &fetched)) && pidlSub && fetched)
688  {
689  LPITEMIDLIST pidlSubComplete;
690  pidlSubComplete = ILCombine(entry, pidlSub);
691 
692  if (InsertItem(hItem, pFolder, pidlSubComplete, pidlSub, FALSE))
693  uItemCount++;
694  ILFree(pidlSubComplete);
695  ILFree(pidlSub);
696  }
697  pNodeInfo->expanded = TRUE;
698  /* Let's do sorting */
699  sortCallback.hParent = hItem;
700  sortCallback.lpfnCompare = CompareTreeItems;
701  sortCallback.lParam = (LPARAM)this;
702  SendMessage(TVM_SORTCHILDRENCB, 0, (LPARAM)&sortCallback);
703 
704  /* Now we can redraw */
706 
707  return (uItemCount > 0) ? TRUE : FALSE;
708 }
709 
719  BOOL bSelect)
720 {
722  HTREEITEM tmp;
724  BOOL found;
725  NodeInfo *nodeData;
726  LPITEMIDLIST relativeChild;
727  TVITEM tvItem;
728 
729  if (!item)
730  return FALSE;
731 
732  found = FALSE;
733  current = hRoot;
734  parent = NULL;
735  while(!found)
736  {
737  nodeData = GetNodeInfo(current);
738  if (!nodeData)
739  {
740  ERR("Something has gone wrong, no data associated to node !\n");
741  *item = NULL;
742  return FALSE;
743  }
744  // If we found our node, give it back
745  if (!pDesktop->CompareIDs(0, nodeData->absolutePidl, dest))
746  {
747  if (bSelect)
748  TreeView_SelectItem(m_hWnd, current);
749  *item = current;
750  return TRUE;
751  }
752 
753  // Check if we are a parent of the requested item
754  relativeChild = ILFindChild(nodeData->absolutePidl, dest);
755  if (relativeChild != 0)
756  {
757  // Notify treeview we have children
758  tvItem.mask = TVIF_CHILDREN;
759  tvItem.hItem = current;
760  tvItem.cChildren = 1;
761  TreeView_SetItem(m_hWnd, &tvItem);
762 
763  // If we can expand and the node isn't expanded yet, do it
764  if (bExpand)
765  {
766  if (!nodeData->expanded)
767  InsertSubitems(current, nodeData);
769  }
770 
771  // Try to get a child
772  tmp = TreeView_GetChild(m_hWnd, current);
773  if (tmp)
774  {
775  // We have a child, let's continue with it
776  parent = current;
777  current = tmp;
778  continue;
779  }
780 
781  if (bInsert && nodeData->expanded)
782  {
783  // Happens when we have to create a subchild inside a child
784  current = InsertItem(current, dest, relativeChild, TRUE);
785  }
786  // We end up here, without any children, so we found nothing
787  // Tell the parent node it has children
788  ZeroMemory(&tvItem, sizeof(tvItem));
789  *item = NULL;
790  return FALSE;
791  }
792 
793  // Find sibling
794  tmp = TreeView_GetNextSibling(m_hWnd, current);
795  if (tmp)
796  {
797  current = tmp;
798  continue;
799  }
800  if (bInsert)
801  {
803  *item = current;
804  return TRUE;
805  }
806  *item = NULL;
807  return FALSE;
808  }
809  return FALSE;
810 }
811 
813 {
814  LPITEMIDLIST explorerPidl;
815  CComPtr<IBrowserService> pBrowserService;
816  HRESULT hr;
818  BOOL result;
819  explorerPidl = NULL;
820 
821  hr = IUnknown_QueryService(pSite, SID_STopLevelBrowser, IID_PPV_ARG(IBrowserService, &pBrowserService));
822  if (!SUCCEEDED(hr))
823  {
824  ERR("Can't get IBrowserService !\n");
825  return FALSE;
826  }
827 
828  hr = pBrowserService->GetPidl(&explorerPidl);
829  if (!SUCCEEDED(hr) || !explorerPidl)
830  {
831  ERR("Unable to get browser PIDL !\n");
832  return FALSE;
833  }
834  bNavigating = TRUE;
835  /* find PIDL into our explorer */
836  result = NavigateToPIDL(explorerPidl, &dummy, TRUE, FALSE, TRUE);
837  bNavigating = FALSE;
838  return result;
839 }
840 
842 {
843  HTREEITEM toDelete;
844  TVITEM tvItem;
845  HTREEITEM parentNode;
846 
847  if (!NavigateToPIDL(idl, &toDelete, FALSE, FALSE, FALSE))
848  return FALSE;
849 
850  // TODO: check that the treeview item is really deleted
851 
852  parentNode = TreeView_GetParent(m_hWnd, toDelete);
853  // Navigate to parent when deleting child item
854  if (!pDesktop->CompareIDs(0, idl, pidlCurrent))
855  {
856  TreeView_SelectItem(m_hWnd, parentNode);
857  }
858 
859  // Remove the child item
860  TreeView_DeleteItem(m_hWnd, toDelete);
861  // Probe parent to see if it has children
862  if (!TreeView_GetChild(m_hWnd, parentNode))
863  {
864  // Decrement parent's child count
865  ZeroMemory(&tvItem, sizeof(tvItem));
866  tvItem.mask = TVIF_CHILDREN;
867  tvItem.hItem = parentNode;
868  tvItem.cChildren = 0;
869  TreeView_SetItem(m_hWnd, &tvItem);
870  }
871  return TRUE;
872 }
873 
875 {
876  WCHAR wszDisplayName[MAX_PATH];
877  TVITEM itemInfo;
878  LPCITEMIDLIST relPidl;
879  NodeInfo *treeInfo;
880  TVSORTCB sortCallback;
882 
883  ZeroMemory(&itemInfo, sizeof(itemInfo));
884  itemInfo.mask = TVIF_PARAM;
885  itemInfo.hItem = toRename;
886 
887  // Change PIDL associated to the item
888  relPidl = ILFindLastID(newPidl);
889  TreeView_GetItem(m_hWnd, &itemInfo);
890  if (!itemInfo.lParam)
891  {
892  ERR("Unable to fetch lParam\n");
893  return FALSE;
894  }
896  treeInfo = (NodeInfo*)itemInfo.lParam;
897  ILFree(treeInfo->absolutePidl);
898  ILFree(treeInfo->relativePidl);
899  treeInfo->absolutePidl = ILClone(newPidl);
900  treeInfo->relativePidl = ILClone(relPidl);
901 
902  // Change the display name
903  GetDisplayName(newPidl, wszDisplayName, MAX_PATH, SHGDN_INFOLDER);
904  ZeroMemory(&itemInfo, sizeof(itemInfo));
905  itemInfo.hItem = toRename;
906  itemInfo.mask = TVIF_TEXT;
907  itemInfo.pszText = wszDisplayName;
908  TreeView_SetItem(m_hWnd, &itemInfo);
909 
910  if((child = TreeView_GetChild(m_hWnd, toRename)) != NULL)
911  {
912  RefreshTreePidl(child, newPidl);
913  }
914 
915  // Sorting
916  sortCallback.hParent = TreeView_GetParent(m_hWnd, toRename);
917  sortCallback.lpfnCompare = CompareTreeItems;
918  sortCallback.lParam = (LPARAM)this;
919  SendMessage(TVM_SORTCHILDRENCB, 0, (LPARAM)&sortCallback);
921  return TRUE;
922 }
923 
925 {
926  HTREEITEM tmp;
927  NodeInfo *pInfo;
928 
929  // Update our node data
930  pInfo = GetNodeInfo(tree);
931  if (!pInfo)
932  {
933  WARN("No tree info !\n");
934  return FALSE;
935  }
936  ILFree(pInfo->absolutePidl);
937  pInfo->absolutePidl = ILCombine(pidlParent, pInfo->relativePidl);
938  if (!pInfo->absolutePidl)
939  {
940  WARN("PIDL allocation failed\n");
941  return FALSE;
942  }
943  // Recursively update children
944  if ((tmp = TreeView_GetChild(m_hWnd, tree)) != NULL)
945  {
946  RefreshTreePidl(tmp, pInfo->absolutePidl);
947  }
948 
949  tmp = TreeView_GetNextSibling(m_hWnd, tree);
950  while(tmp != NULL)
951  {
952  pInfo = GetNodeInfo(tmp);
953  if(!pInfo)
954  {
955  WARN("No tree info !\n");
956  continue;
957  }
958  ILFree(pInfo->absolutePidl);
959  pInfo->absolutePidl = ILCombine(pidlParent, pInfo->relativePidl);
960  tmp = TreeView_GetNextSibling(m_hWnd, tmp);
961  }
962  return TRUE;
963 }
964 
965 // *** Tree item sorting callback ***
967 {
968  /*
969  * We first sort drive letters (Path root), then PIDLs and then regular folder
970  * display name.
971  * This is not how Windows sorts item, but it gives decent results.
972  */
973  NodeInfo *info1;
974  NodeInfo *info2;
975  CExplorerBand *pThis;
976  WCHAR wszFolder1[MAX_PATH];
977  WCHAR wszFolder2[MAX_PATH];
978 
979  info1 = (NodeInfo*)p1;
980  info2 = (NodeInfo*)p2;
981  pThis = (CExplorerBand*)p3;
982 
983  GetDisplayName(info1->absolutePidl, wszFolder1, MAX_PATH, SHGDN_FORPARSING);
984  GetDisplayName(info2->absolutePidl, wszFolder2, MAX_PATH, SHGDN_FORPARSING);
985  if (PathIsRoot(wszFolder1) && PathIsRoot(wszFolder2))
986  {
987  return lstrcmpiW(wszFolder1,wszFolder2);
988  }
989  if (PathIsRoot(wszFolder1) && !PathIsRoot(wszFolder2))
990  {
991  return -1;
992  }
993  if (!PathIsRoot(wszFolder1) && PathIsRoot(wszFolder2))
994  {
995  return 1;
996  }
997  // Now, we compare non-root folders, grab display name
998  GetDisplayName(info1->absolutePidl, wszFolder1, MAX_PATH, SHGDN_INFOLDER);
999  GetDisplayName(info2->absolutePidl, wszFolder2, MAX_PATH, SHGDN_INFOLDER);
1000 
1002  {
1003  return -1;
1004  }
1006  {
1007  return 1;
1008  }
1010  {
1011  HRESULT hr;
1012  hr = pThis->pDesktop->CompareIDs(0, info1->absolutePidl, info2->absolutePidl);
1013  if (!hr) return 0;
1014  return (hr > 0) ? -1 : 1;
1015  }
1016  return StrCmpLogicalW(wszFolder1, wszFolder2);
1017 }
1018 
1019 // *** IOleWindow methods ***
1021 {
1022  if (!lphwnd)
1023  return E_INVALIDARG;
1024  *lphwnd = m_hWnd;
1025  return S_OK;
1026 }
1027 
1029 {
1030  UNIMPLEMENTED;
1031  return E_NOTIMPL;
1032 }
1033 
1034 
1035 // *** IDockingWindow methods ***
1037 {
1038  // We do nothing, we don't have anything to save yet
1039  TRACE("CloseDW called\n");
1040  return S_OK;
1041 }
1042 
1043 HRESULT STDMETHODCALLTYPE CExplorerBand::ResizeBorderDW(const RECT *prcBorder, IUnknown *punkToolbarSite, BOOL fReserved)
1044 {
1045  /* Must return E_NOTIMPL according to MSDN */
1046  return E_NOTIMPL;
1047 }
1048 
1050 {
1051  fVisible = fShow;
1052  ShowWindow(fShow);
1053  return S_OK;
1054 }
1055 
1056 
1057 // *** IDeskBand methods ***
1059 {
1060  if (!pdbi)
1061  {
1062  return E_INVALIDARG;
1063  }
1064  this->dwBandID = dwBandID;
1065 
1066  if (pdbi->dwMask & DBIM_MINSIZE)
1067  {
1068  pdbi->ptMinSize.x = 200;
1069  pdbi->ptMinSize.y = 30;
1070  }
1071 
1072  if (pdbi->dwMask & DBIM_MAXSIZE)
1073  {
1074  pdbi->ptMaxSize.y = -1;
1075  }
1076 
1077  if (pdbi->dwMask & DBIM_INTEGRAL)
1078  {
1079  pdbi->ptIntegral.y = 1;
1080  }
1081 
1082  if (pdbi->dwMask & DBIM_ACTUAL)
1083  {
1084  pdbi->ptActual.x = 200;
1085  pdbi->ptActual.y = 30;
1086  }
1087 
1088  if (pdbi->dwMask & DBIM_TITLE)
1089  {
1090  if (!LoadStringW(_AtlBaseModule.GetResourceInstance(), IDS_FOLDERSLABEL, pdbi->wszTitle, _countof(pdbi->wszTitle)))
1091  return HRESULT_FROM_WIN32(GetLastError());
1092  }
1093 
1094  if (pdbi->dwMask & DBIM_MODEFLAGS)
1095  {
1096  pdbi->dwModeFlags = DBIMF_NORMAL | DBIMF_VARIABLEHEIGHT;
1097  }
1098 
1099  if (pdbi->dwMask & DBIM_BKCOLOR)
1100  {
1101  pdbi->dwMask &= ~DBIM_BKCOLOR;
1102  }
1103  return S_OK;
1104 }
1105 
1106 
1107 // *** IObjectWithSite methods ***
1109 {
1110  HRESULT hr;
1111  HWND parentWnd;
1112 
1113  if (pUnkSite == pSite)
1114  return S_OK;
1115 
1116  TRACE("SetSite called \n");
1117  if (!pUnkSite)
1118  {
1120  DestroyWindow();
1121  m_hWnd = NULL;
1122  }
1123 
1124  if (pUnkSite != pSite)
1125  {
1126  pSite = NULL;
1127  }
1128 
1129  if(!pUnkSite)
1130  return S_OK;
1131 
1132  hr = IUnknown_GetWindow(pUnkSite, &parentWnd);
1133  if (!SUCCEEDED(hr))
1134  {
1135  ERR("Could not get parent's window ! Status: %08lx\n", hr);
1136  return E_INVALIDARG;
1137  }
1138 
1139  pSite = pUnkSite;
1140 
1141  if (m_hWnd)
1142  {
1143  // Change its parent
1144  SetParent(parentWnd);
1145  }
1146  else
1147  {
1149  WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | TVS_HASLINES | TVS_HASBUTTONS | TVS_SHOWSELALWAYS | TVS_EDITLABELS /* | TVS_SINGLEEXPAND*/ , // remove TVS_SINGLEEXPAND for now since it has strange behaviour
1150  0, 0, 0, 0, parentWnd, NULL, _AtlBaseModule.GetModuleInstance(), NULL);
1151 
1152  // Subclass the window
1153  SubclassWindow(wnd);
1154 
1155  // Initialize our treeview now
1157  RegisterDragDrop(m_hWnd, dynamic_cast<IDropTarget*>(this));
1158  }
1159  return S_OK;
1160 }
1161 
1163 {
1164  if (!ppvSite)
1165  return E_POINTER;
1166  *ppvSite = pSite;
1167  return S_OK;
1168 }
1169 
1170 
1171 // *** IOleCommandTarget methods ***
1172 HRESULT STDMETHODCALLTYPE CExplorerBand::QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds [], OLECMDTEXT *pCmdText)
1173 {
1174  UNIMPLEMENTED;
1175  return E_NOTIMPL;
1176 }
1177 
1178 HRESULT STDMETHODCALLTYPE CExplorerBand::Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
1179 {
1180  UNIMPLEMENTED;
1181  return E_NOTIMPL;
1182 }
1183 
1184 
1185 // *** IServiceProvider methods ***
1187 {
1188  /* FIXME: we probably want to handle more services here */
1190 }
1191 
1192 
1193 // *** IInputObject methods ***
1195 {
1196  if (fActivate)
1197  {
1198  //SetFocus();
1199  SetActiveWindow();
1200  }
1201  // TODO: handle message
1202  if(lpMsg)
1203  {
1204  TranslateMessage(lpMsg);
1205  DispatchMessage(lpMsg);
1206  }
1207  return S_OK;
1208 }
1209 
1211 {
1212  return bFocused ? S_OK : S_FALSE;
1213 }
1214 
1216 {
1217  if (lpMsg->hwnd == m_hWnd)
1218  {
1219  TranslateMessage(lpMsg);
1220  DispatchMessage(lpMsg);
1221  return S_OK;
1222  }
1223 
1224  return S_FALSE;
1225 }
1226 
1227 // *** IPersist methods ***
1229 {
1230  if (!pClassID)
1231  return E_POINTER;
1232  memcpy(pClassID, &CLSID_ExplorerBand, sizeof(CLSID));
1233  return S_OK;
1234 }
1235 
1236 
1237 // *** IPersistStream methods ***
1239 {
1240  UNIMPLEMENTED;
1241  return E_NOTIMPL;
1242 }
1243 
1245 {
1246  UNIMPLEMENTED;
1247  return E_NOTIMPL;
1248 }
1249 
1251 {
1252  UNIMPLEMENTED;
1253  return E_NOTIMPL;
1254 }
1255 
1257 {
1258  // TODO: calculate max size
1259  UNIMPLEMENTED;
1260  return E_NOTIMPL;
1261 }
1262 
1263 
1264 // *** IWinEventHandler methods ***
1266 {
1267  BOOL bHandled;
1268  LRESULT result;
1269 
1270  if (uMsg == WM_NOTIFY)
1271  {
1272  NMHDR *pNotifyHeader = (NMHDR*)lParam;
1273  switch (pNotifyHeader->code)
1274  {
1275  case TVN_ITEMEXPANDING:
1277  if (theResult)
1278  *theResult = result;
1279  break;
1280  case TVN_SELCHANGED:
1282  break;
1283  case TVN_DELETEITEM:
1285  break;
1286  case NM_RCLICK:
1287  OnContextMenu(WM_CONTEXTMENU, (WPARAM)m_hWnd, GetMessagePos(), bHandled);
1288  if (theResult)
1289  *theResult = 1;
1290  break;
1291  case TVN_BEGINDRAG:
1292  case TVN_BEGINRDRAG:
1294  case TVN_BEGINLABELEDITW:
1295  {
1296  // TODO: put this in a function ? (mostly copypasta from CDefView)
1297  DWORD dwAttr = SFGAO_CANRENAME;
1298  LPNMTVDISPINFO dispInfo = (LPNMTVDISPINFO)lParam;
1299  CComPtr<IShellFolder> pParent;
1300  LPCITEMIDLIST pChild;
1301  HRESULT hr;
1302 
1303  if (theResult)
1304  *theResult = 1;
1305  NodeInfo *info = GetNodeInfo(dispInfo->item.hItem);
1306  if (!info)
1307  return E_FAIL;
1308  hr = SHBindToParent(info->absolutePidl, IID_PPV_ARG(IShellFolder, &pParent), &pChild);
1309  if (!SUCCEEDED(hr) || !pParent.p)
1310  return E_FAIL;
1311 
1312  hr = pParent->GetAttributesOf(1, &pChild, &dwAttr);
1313  if (SUCCEEDED(hr) && (dwAttr & SFGAO_CANRENAME) && theResult)
1314  *theResult = 0;
1315  return S_OK;
1316  }
1317  case TVN_ENDLABELEDITW:
1318  {
1319  LPNMTVDISPINFO dispInfo = (LPNMTVDISPINFO)lParam;
1320  NodeInfo *info = GetNodeInfo(dispInfo->item.hItem);
1321  HRESULT hr;
1322 
1323  if (theResult)
1324  *theResult = 0;
1325  if (dispInfo->item.pszText)
1326  {
1327  LPITEMIDLIST pidlNew;
1328  CComPtr<IShellFolder> pParent;
1329  LPCITEMIDLIST pidlChild;
1330 
1331  hr = SHBindToParent(info->absolutePidl, IID_PPV_ARG(IShellFolder, &pParent), &pidlChild);
1332  if (!SUCCEEDED(hr) || !pParent.p)
1333  return E_FAIL;
1334 
1335  hr = pParent->SetNameOf(0, pidlChild, dispInfo->item.pszText, SHGDN_INFOLDER, &pidlNew);
1336  if(SUCCEEDED(hr) && pidlNew)
1337  {
1338  CComPtr<IPersistFolder2> pPersist;
1339  LPITEMIDLIST pidlParent, pidlNewAbs;
1340 
1341  hr = pParent->QueryInterface(IID_PPV_ARG(IPersistFolder2, &pPersist));
1342  if(!SUCCEEDED(hr))
1343  return E_FAIL;
1344 
1345  hr = pPersist->GetCurFolder(&pidlParent);
1346  if(!SUCCEEDED(hr))
1347  return E_FAIL;
1348  pidlNewAbs = ILCombine(pidlParent, pidlNew);
1349 
1350  // Navigate to our new location
1351  UpdateBrowser(pidlNewAbs);
1352 
1353  ILFree(pidlNewAbs);
1354  ILFree(pidlNew);
1355  if (theResult)
1356  *theResult = 1;
1357  }
1358  return S_OK;
1359  }
1360  }
1361  default:
1362  break;
1363  }
1364  }
1365  return S_OK;
1366 }
1367 
1369 {
1370  return (hWnd == m_hWnd) ? S_OK : S_FALSE;
1371 }
1372 
1373 // *** IBandNavigate methods ***
1375 {
1376  UNIMPLEMENTED;
1377  return E_NOTIMPL;
1378 }
1379 
1380 // *** INamespaceProxy ***
1381 HRESULT STDMETHODCALLTYPE CExplorerBand::GetNavigateTarget(long paramC, long param10, long param14)
1382 {
1383  UNIMPLEMENTED;
1384  return E_NOTIMPL;
1385 }
1386 
1388 {
1389  UNIMPLEMENTED;
1390  return E_NOTIMPL;
1391 }
1392 
1394 {
1395  UNIMPLEMENTED;
1396  return E_NOTIMPL;
1397 }
1398 
1399 HRESULT STDMETHODCALLTYPE CExplorerBand::RefreshFlags(long paramC, long param10, long param14)
1400 {
1401  UNIMPLEMENTED;
1402  return E_NOTIMPL;
1403 }
1404 
1406 {
1407  UNIMPLEMENTED;
1408  return E_NOTIMPL;
1409 }
1410 
1411 // *** IDispatch methods ***
1413 {
1414  UNIMPLEMENTED;
1415  return E_NOTIMPL;
1416 }
1417 
1419 {
1420  UNIMPLEMENTED;
1421  return E_NOTIMPL;
1422 }
1423 
1425 {
1426  UNIMPLEMENTED;
1427  return E_NOTIMPL;
1428 }
1429 
1430 HRESULT STDMETHODCALLTYPE CExplorerBand::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1431 {
1432  switch (dispIdMember)
1433  {
1436  TRACE("DISPID_NAVIGATECOMPLETE2 received\n");
1438  return S_OK;
1439  }
1440  TRACE("Unknown dispid requested: %08x\n", dispIdMember);
1441  return E_INVALIDARG;
1442 }
1443 
1444 // *** IDropTarget methods ***
1446 {
1447  ERR("Entering drag\n");
1448  pCurObject = pObj;
1450  return DragOver(glfKeyState, pt, pdwEffect);
1451 }
1452 
1454 {
1456  CComPtr<IShellFolder> pShellFldr;
1457  NodeInfo *nodeInfo;
1458  //LPCITEMIDLIST pChild;
1459  HRESULT hr;
1460 
1461  info.pt.x = pt.x;
1462  info.pt.y = pt.y;
1463  info.flags = TVHT_ONITEM;
1464  info.hItem = NULL;
1465  ScreenToClient(&info.pt);
1466 
1467  // Move to the item selected by the treeview (don't change right pane)
1468  TreeView_HitTest(m_hWnd, &info);
1469 
1470  if (info.hItem)
1471  {
1472  bNavigating = TRUE;
1473  TreeView_SelectItem(m_hWnd, info.hItem);
1474  bNavigating = FALSE;
1475  // Delegate to shell folder
1476  if (pDropTarget && info.hItem != childTargetNode)
1477  {
1478  pDropTarget = NULL;
1479  }
1480  if (info.hItem != childTargetNode)
1481  {
1482  nodeInfo = GetNodeInfo(info.hItem);
1483  if (!nodeInfo)
1484  return E_FAIL;
1485 #if 0
1486  hr = SHBindToParent(nodeInfo->absolutePidl, IID_PPV_ARG(IShellFolder, &pShellFldr), &pChild);
1487  if (!SUCCEEDED(hr))
1488  return E_FAIL;
1489  hr = pShellFldr->GetUIObjectOf(m_hWnd, 1, &pChild, IID_IDropTarget, NULL, reinterpret_cast<void**>(&pDropTarget));
1490  if (!SUCCEEDED(hr))
1491  return E_FAIL;
1492 #endif
1493  if(_ILIsDesktop(nodeInfo->absolutePidl))
1494  pShellFldr = pDesktop;
1495  else
1496  {
1497  hr = pDesktop->BindToObject(nodeInfo->absolutePidl, 0, IID_PPV_ARG(IShellFolder, &pShellFldr));
1498  if (!SUCCEEDED(hr))
1499  {
1500  /* Don't allow dnd since we couldn't get our folder object */
1501  ERR("Can't bind to folder object\n");
1502  *pdwEffect = DROPEFFECT_NONE;
1503  return E_FAIL;
1504  }
1505  }
1506  hr = pShellFldr->CreateViewObject(m_hWnd, IID_PPV_ARG(IDropTarget, &pDropTarget));
1507  if (!SUCCEEDED(hr))
1508  {
1509  /* Don't allow dnd since we couldn't get our drop target */
1510  ERR("Can't get drop target for folder object\n");
1511  *pdwEffect = DROPEFFECT_NONE;
1512  return E_FAIL;
1513  }
1514  hr = pDropTarget->DragEnter(pCurObject, glfKeyState, pt, pdwEffect);
1515  childTargetNode = info.hItem;
1516  }
1517  if (pDropTarget)
1518  {
1519  hr = pDropTarget->DragOver(glfKeyState, pt, pdwEffect);
1520  }
1521  }
1522  else
1523  {
1525  pDropTarget = NULL;
1526  *pdwEffect = DROPEFFECT_NONE;
1527  }
1528  return S_OK;
1529 }
1530 
1532 {
1533  bNavigating = TRUE;
1535  bNavigating = FALSE;
1537  if (pCurObject)
1538  {
1539  pCurObject = NULL;
1540  }
1541  return S_OK;
1542 }
1543 
1545 {
1546  if (!pDropTarget)
1547  return E_FAIL;
1548  pDropTarget->Drop(pObj, glfKeyState, pt, pdwEffect);
1549  DragLeave();
1550  return S_OK;
1551 }
1552 
1553 // *** IDropSource methods ***
1555 {
1556  if (fEscapePressed)
1557  return DRAGDROP_S_CANCEL;
1558  if ((grfKeyState & MK_LBUTTON) || (grfKeyState & MK_RBUTTON))
1559  return S_OK;
1560  return DRAGDROP_S_DROP;
1561 }
1562 
1564 {
1566 }
DBIM_BKCOLOR struct tagDESKBANDINFO DESKBANDINFO
LPITEMIDLIST relativePidl
Definition: explorerband.h:49
#define SHCNE_MKDIR
Definition: shlobj.h:1723
#define WS_CLIPSIBLINGS
Definition: pedump.c:618
ULONG WINAPI SHChangeNotifyRegister(HWND hwnd, int fSources, LONG wEventMask, UINT uMsg, int cItems, SHChangeNotifyEntry *lpItems)
Definition: changenotify.c:215
CComPtr< IDataObject > pCurObject
Definition: explorerband.h:74
return
Definition: dirsup.c:529
#define DispatchMessage
Definition: winuser.h:5631
BOOL WINAPI TranslateMessage(_In_ const MSG *)
BOOL OnTreeItemDeleted(LPNMTREEVIEW pnmtv)
BOOL NavigateToPIDL(LPITEMIDLIST dest, HTREEITEM *item, BOOL bExpand, BOOL bInsert, BOOL bSelect)
virtual HRESULT STDMETHODCALLTYPE GetNavigateTarget(long paramC, long param10, long param14)
#define REFIID
Definition: guiddef.h:113
#define TRUE
Definition: types.h:120
#define SHCNE_RMDIR
Definition: shlobj.h:1724
void WINAPI ILFree(LPITEMIDLIST pidl)
Definition: pidl.c:925
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92
Definition: fci.c:115
#define SHCNE_DISKEVENTS
Definition: shlobj.h:1742
#define WM_CONTEXTMENU
Definition: richedit.h:64
#define CreateWindow
Definition: winuser.h:5620
HRESULT hr
Definition: shlfolder.c:183
Definition: scsiwmi.h:51
#define MK_LBUTTON
Definition: winuser.h:2321
HRESULT WINAPI AtlAdvise(IUnknown *pUnkCP, IUnknown *pUnk, const IID *iid, DWORD *pdw)
Definition: atl.c:46
void OnSelectionChanged(LPNMTREEVIEW pnmtv)
#define TreeView_DeleteAllItems(hwnd)
Definition: commctrl.h:3389
virtual HRESULT STDMETHODCALLTYPE GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
#define CSIDL_DESKTOP
Definition: shlobj.h:2003
virtual HRESULT STDMETHODCALLTYPE DragEnter(IDataObject *pObj, DWORD glfKeyState, POINTL pt, DWORD *pdwEffect)
#define pt(x, y)
Definition: drawing.c:79
#define TPM_LEFTALIGN
Definition: winuser.h:2331
REFIID riid
Definition: precomp.h:44
HWND WINAPI SetParent(_In_ HWND, _In_opt_ HWND)
#define TVM_SORTCHILDRENCB
Definition: commctrl.h:3519
#define _countof(array)
Definition: fontsub.cpp:30
#define TPM_RETURNCMD
Definition: winuser.h:2341
HRESULT WINAPI StrRetToBufW(LPSTRRET src, const ITEMIDLIST *pidl, LPWSTR dest, UINT len)
Definition: string.c:1522
virtual HRESULT STDMETHODCALLTYPE QueryService(REFGUID guidService, REFIID riid, void **ppvObject)
virtual HRESULT STDMETHODCALLTYPE QueryContinueDrag(BOOL fEscapePressed, DWORD grfKeyState)
virtual HRESULT STDMETHODCALLTYPE Load(IStream *pStm)
#define TreeView_GetChild(hwnd, hitem)
Definition: commctrl.h:3438
HRESULT WINAPI IUnknown_OnFocusChangeIS(LPUNKNOWN lpUnknown, LPUNKNOWN pFocusObject, BOOL bFocus)
Definition: ordinal.c:4594
virtual HRESULT STDMETHODCALLTYPE TranslateAcceleratorIO(LPMSG lpMsg)
NodeInfo * GetNodeInfo(HTREEITEM hItem)
virtual HRESULT STDMETHODCALLTYPE GetSite(REFIID riid, void **ppvSite)
uint8_t entry
Definition: isohybrid.c:63
#define WARN(fmt,...)
Definition: debug.h:111
LPITEMIDLIST WINAPI ILCombine(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
Definition: pidl.c:699
#define SHCNE_RENAMEFOLDER
Definition: shlobj.h:1737
const ITEMIDLIST UNALIGNED * LPCITEMIDLIST
Definition: shtypes.idl:42
#define CALLBACK
Definition: compat.h:27
#define WM_SETREDRAW
Definition: winuser.h:1598
#define SHCNE_INTERRUPT
Definition: shlobj.h:1745
HWND hWnd
Definition: settings.c:17
HTREEITEM oldSelected
Definition: explorerband.h:64
virtual HRESULT STDMETHODCALLTYPE GetClassID(CLSID *pClassID)
#define LPNMTREEVIEW
Definition: commctrl.h:3615
virtual HRESULT STDMETHODCALLTYPE Select(long paramC)
#define DISPID_DOWNLOADCOMPLETE
Definition: webchild.h:39
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
#define ZeroMemory
Definition: winbase.h:1635
HRESULT _ReparsePIDL(LPITEMIDLIST buggyPidl, LPITEMIDLIST *cleanPidl)
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
#define MAKEINTRESOURCEA(i)
Definition: winuser.h:581
#define FCIDM_SHVIEWFIRST
Definition: shlobj.h:499
HWND WINAPI SetFocus(_In_opt_ HWND)
const GUID IID_IDataObject
HRESULT WINAPI RegisterDragDrop(HWND hwnd, LPDROPTARGET pDropTarget)
Definition: ole2.c:560
static int CALLBACK CompareTreeItems(LPARAM p1, LPARAM p2, LPARAM p3)
#define SHCNRF_RecursiveInterrupt
Definition: shlobj.h:1767
DWORD LCID
Definition: nls.h:13
UINT_PTR WPARAM
Definition: windef.h:207
int cChildren
Definition: treeview.c:154
#define WS_CHILD
Definition: pedump.c:617
DWORD WINAPI GetMessagePos(void)
Definition: message.c:1350
#define TreeView_GetNextSibling(hwnd, hitem)
Definition: commctrl.h:3439
#define TVIF_SELECTEDIMAGE
Definition: commctrl.h:3243
UINT uFlags
Definition: api.c:60
BOOL WINAPI ShowWindow(_In_ HWND, _In_ int)
#define WS_CLIPCHILDREN
Definition: pedump.c:619
static LPOLESTR
Definition: stg_prop.c:27
#define TVN_BEGINDRAG
Definition: commctrl.h:3712
#define IID_PPV_ARG(Itype, ppType)
#define E_FAIL
Definition: ddrawi.h:102
HRESULT WINAPI IUnknown_GetWindow(IUnknown *lpUnknown, HWND *lphWnd)
Definition: ordinal.c:1283
BOOL WINAPI DestroyWindow(_In_ HWND)
int WINAPI LoadStringW(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_writes_to_(cchBufferMax, return+1) LPWSTR lpBuffer, _In_ int cchBufferMax)
int32_t INT
Definition: typedefs.h:56
HRESULT WINAPI IUnknown_QueryService(IUnknown *, REFGUID, REFIID, LPVOID *)
Definition: ordinal.c:1448
HRESULT WINAPI RevokeDragDrop(HWND hwnd)
Definition: ole2.c:642
static HWND child
Definition: cursoricon.c:298
virtual HRESULT STDMETHODCALLTYPE Save(IStream *pStm, BOOL fClearDirty)
WPARAM wParam
Definition: combotst.c:138
#define DRAGDROP_S_CANCEL
Definition: winerror.h:2647
HTREEITEM InsertItem(HTREEITEM hParent, IShellFolder *psfParent, LPITEMIDLIST pElt, LPITEMIDLIST pEltRelative, BOOL bSort)
const DWORD DROPEFFECT_COPY
Definition: oleidl.idl:930
int WINAPI lstrcmpiW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:194
ULONG shellRegID
Definition: explorerband.h:69
struct _test_info info[]
Definition: SetCursorPos.c:19
HRESULT GetDisplayNameOf([in] PCUITEMID_CHILD pidl, [in] SHGDNF uFlags, [out] STRRET *lpName)
HRESULT ExecuteCommand(CComPtr< IContextMenu > &menu, UINT nCmd)
UINT code
Definition: winuser.h:3112
virtual HRESULT STDMETHODCALLTYPE GetWindow(HWND *lphwnd)
#define TreeView_InsertItem(hwnd, lpis)
Definition: commctrl.h:3384
#define TVN_ENDLABELEDITW
Definition: commctrl.h:3684
const DWORD DROPEFFECT_NONE
Definition: oleidl.idl:929
#define TPM_RIGHTBUTTON
Definition: winuser.h:2334
BOOL OnTreeItemExpanding(LPNMTREEVIEW pnmtv)
virtual HRESULT STDMETHODCALLTYPE IsDirty()
#define WM_USER_SHELLEVENT
Definition: explorerband.h:23
#define TVIF_CHILDREN
Definition: commctrl.h:3244
HWND WINAPI SetActiveWindow(_In_ HWND)
static BOOL _ILIsSpecialFolder(LPCITEMIDLIST pidl)
BOOL RefreshTreePidl(HTREEITEM tree, LPITEMIDLIST pidlParent)
_In_ HANDLE _In_ DWORD _In_ DWORD _Inout_opt_ LPOVERLAPPED _In_opt_ LPTRANSMIT_FILE_BUFFERS _In_ DWORD dwReserved
Definition: mswsock.h:90
unsigned int BOOL
Definition: ntddk_ex.h:94
BOOL NavigateToCurrentFolder()
#define SubclassWindow(hwnd, lpfn)
Definition: windowsx.h:512
BOOL DeleteItem(LPITEMIDLIST toDelete)
HRESULT WINAPI SHGetImageList(int iImageList, REFIID riid, void **ppv)
Definition: shellord.c:2007
#define StrRetToBuf
Definition: shlwapi.h:1769
#define TVS_HASBUTTONS
Definition: commctrl.h:3219
HRESULT WINAPI IUnknown_SetSite(IUnknown *obj, IUnknown *site)
Definition: ordinal.c:1358
virtual HRESULT STDMETHODCALLTYPE GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static PVOID ptr
Definition: dispmode.c:27
ULONG Release()
#define S_FALSE
Definition: winerror.h:2357
#define TVN_BEGINRDRAG
Definition: commctrl.h:3713
#define VK_SHIFT
Definition: winuser.h:2156
#define E_INVALIDARG
Definition: ddrawi.h:101
HTREEITEM hItem
Definition: treelist.h:37
#define DISPID_NAVIGATECOMPLETE2
Definition: webchild.h:54
const WCHAR * str
HRESULT GetAttributesOf([in] UINT cidl, [in, size_is(cidl)] PCUITEMID_CHILD_ARRAY apidl, [in, out] SFGAOF *rgfInOut)
#define SHCNRF_InterruptLevel
Definition: shlobj.h:1765
smooth NULL
Definition: ftsmooth.c:416
#define SID_SWebBrowserApp
Definition: shlguid.h:108
#define TVE_COLLAPSE
Definition: commctrl.h:3394
LPITEMIDLIST absolutePidl
Definition: explorerband.h:48
LONG_PTR LPARAM
Definition: windef.h:208
LPITEMIDLIST WINAPI ILFindLastID(LPCITEMIDLIST pidl)
Definition: pidl.c:189
#define TVI_LAST
Definition: commctrl.h:3342
HTREEITEM childTargetNode
Definition: explorerband.h:73
struct CFFOLDER folder
Definition: fdi.c:110
#define TreeView_SetImageList(hwnd, himl, iImage)
Definition: commctrl.h:3419
#define MK_RBUTTON
Definition: winuser.h:2322
BOOL _ILIsDesktop(LPCITEMIDLIST pidl)
Definition: CBandSite.h:24
#define FCIDM_SHVIEWLAST
Definition: shlobj.h:532
#define WM_RBUTTONDOWN
Definition: winuser.h:1755
SHORT WINAPI GetKeyState(_In_ int)
virtual HRESULT STDMETHODCALLTYPE UIActivateIO(BOOL fActivate, LPMSG lpMsg)
#define TreeView_DeleteItem(hwnd, hitem)
Definition: commctrl.h:3387
char TCHAR
Definition: xmlstorage.h:189
#define PT_YAGUID
#define TRACE(s)
Definition: solgame.cpp:4
HRESULT WINAPI AtlUnadvise(IUnknown *pUnkCP, const IID *iid, DWORD dw)
Definition: atl.c:74
#define TreeView_GetSelection(hwnd)
Definition: commctrl.h:3445
HRESULT WINAPI SHGetDesktopFolder(IShellFolder **psf)
HRESULT UpdateBrowser(LPITEMIDLIST pidlGoto)
#define WC_TREEVIEW
Definition: commctrl.h:3217
r parent
Definition: btrfs.c:2659
#define TreeView_HitTest(hwnd, lpht)
Definition: commctrl.h:3485
__wchar_t WCHAR
Definition: xmlstorage.h:180
LPITEMIDLIST WINAPI ILFindChild(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
Definition: pidl.c:641
CComPtr< IDropTarget > pDropTarget
Definition: explorerband.h:72
LONG HRESULT
Definition: typedefs.h:77
#define TVN_SELCHANGED
Definition: commctrl.h:3707
struct _PIDLDATA PIDLDATA
#define FAILED_UNEXPECTEDLY(hr)
Definition: shellutils.h:35
#define MAX_PATH
Definition: compat.h:26
#define SHCNRF_ShellLevel
Definition: shlobj.h:1766
#define STDMETHODCALLTYPE
Definition: bdasup.h:9
unsigned short WORD
Definition: ntddk_ex.h:93
unsigned long DWORD
Definition: ntddk_ex.h:95
HTREEITEM hRoot
Definition: explorerband.h:63
#define DRAGDROP_S_USEDEFAULTCURSORS
Definition: winerror.h:2648
virtual HRESULT STDMETHODCALLTYPE DragLeave()
LRESULT OnKillFocus(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
virtual HRESULT STDMETHODCALLTYPE ResizeBorderDW(const RECT *prcBorder, IUnknown *punkToolbarSite, BOOL fReserved)
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
virtual HRESULT STDMETHODCALLTYPE Drop(IDataObject *pObj, DWORD glfKeyState, POINTL pt, DWORD *pdwEffect)
#define TVE_EXPAND
Definition: commctrl.h:3395
UINT cchMax
void InitializeExplorerBand()
virtual HRESULT STDMETHODCALLTYPE HasFocusIO()
virtual HRESULT STDMETHODCALLTYPE IsWindowOwner(HWND hWnd)
virtual HRESULT STDMETHODCALLTYPE Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
INT WINAPI StrCmpLogicalW(LPCWSTR lpszStr, LPCWSTR lpszComp)
Definition: string.c:2296
virtual HRESULT STDMETHODCALLTYPE CacheItem(long paramC)
#define IDS_FOLDERSLABEL
Definition: resource.h:122
virtual HRESULT STDMETHODCALLTYPE SetSite(IUnknown *pUnkSite)
virtual HRESULT STDMETHODCALLTYPE GetSizeMax(ULARGE_INTEGER *pcbSize)
const DOCKBAR PVOID HWND hParent
Definition: tooldock.h:22
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
unsigned char BYTE
Definition: mem.h:68
#define TreeView_GetParent(hwnd, hitem)
Definition: commctrl.h:3441
REFIID LPVOID * ppvObject
Definition: precomp.h:44
LPCITEMIDLIST pidl
Definition: shlobj.h:1716
static const WCHAR Cleanup[]
Definition: register.c:80
virtual HRESULT STDMETHODCALLTYPE DragOver(DWORD glfKeyState, POINTL pt, DWORD *pdwEffect)
#define TVN_BEGINLABELEDITW
Definition: commctrl.h:3682
void OnTreeItemDragging(LPNMTREEVIEW pnmtv, BOOL isRightClick)
virtual HRESULT STDMETHODCALLTYPE Invoke(long paramC)
HRESULT GetDisplayName(LPCITEMIDLIST pidlDirectory, TCHAR *szDisplayName, UINT cchMax, DWORD uFlags)
DWORD adviseCookie
Definition: explorerband.h:68
virtual HRESULT STDMETHODCALLTYPE RefreshFlags(long paramC, long param10, long param14)
BOOL WINAPI DestroyMenu(_In_ HMENU)
#define TVIS_EXPANDED
Definition: commctrl.h:3256
HTREEITEM hParent
Definition: commctrl.h:3586
static BOOL bInsert
Definition: cmdinput.c:121
#define TVITEM
Definition: commctrl.h:3337
_In_ DWORD _Out_ _In_ WORD wFlags
Definition: wincon.h:519
#define ERR(fmt,...)
Definition: debug.h:109
#define TVN_ITEMEXPANDING
Definition: commctrl.h:3710
PFNTVCOMPARE lpfnCompare
Definition: commctrl.h:3587
struct stdole::EXCEPINFO EXCEPINFO
virtual ~CExplorerBand()
#define TV_ITEM
Definition: commctrl.h:3272
static VARIANTARG static DISPID
Definition: ordinal.c:49
#define S_OK
Definition: intsafe.h:59
LRESULT OnShellEvent(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
CComPtr< IShellFolder > pDesktop
Definition: explorerband.h:55
static ATOM item
Definition: dde.c:856
virtual HRESULT STDMETHODCALLTYPE GetBandInfo(DWORD dwBandID, DWORD dwViewMode, DESKBANDINFO *pdbi)
const DWORD DROPEFFECT_MOVE
Definition: oleidl.idl:931
BOOL InsertSubitems(HTREEITEM hItem, NodeInfo *pNodeInfo)
#define TVN_DELETEITEM
Definition: commctrl.h:3714
HRESULT WINAPI SHBindToParent(LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppv, LPCITEMIDLIST *ppidlLast)
Definition: pidl.c:1323
virtual HRESULT STDMETHODCALLTYPE OnWinEvent(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *theResult)
#define TVIF_TEXT
Definition: commctrl.h:3238
unsigned char dummy
Definition: maze.c:118
#define NM_RCLICK
Definition: commctrl.h:133
LPITEMIDLIST WINAPI ILClone(LPCITEMIDLIST pidl)
Definition: pidl.c:228
#define TreeView_SelectItem(hwnd, hitem)
Definition: commctrl.h:3453
virtual HRESULT STDMETHODCALLTYPE QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds [], OLECMDTEXT *pCmdText)
#define DRAGDROP_S_DROP
Definition: winerror.h:2646
#define E_NOTIMPL
Definition: ddrawi.h:99
HRESULT WINAPI DoDragDrop(IDataObject *pDataObject, IDropSource *pDropSource, DWORD dwOKEffect, DWORD *pdwEffect)
Definition: ole2.c:756
BOOL RenameItem(HTREEITEM toRename, LPITEMIDLIST newPidl)
virtual HRESULT STDMETHODCALLTYPE CloseDW(DWORD dwReserved)
virtual HRESULT STDMETHODCALLTYPE GiveFeedback(DWORD dwEffect)
#define TVIF_IMAGE
Definition: commctrl.h:3239
#define SHCNE_UPDATEDIR
Definition: shlobj.h:1732
unsigned int UINT
Definition: ndis.h:50
virtual HRESULT STDMETHODCALLTYPE ContextSensitiveHelp(BOOL fEnterMode)
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
LRESULT OnSetFocus(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
HWND hwnd
Definition: winuser.h:3067
CComPtr< IUnknown > pSite
Definition: explorerband.h:54
#define TreeView_SetItem(hwnd, pitem)
Definition: commctrl.h:3469
#define LPNMTVDISPINFO
Definition: commctrl.h:3648
#define VK_CONTROL
Definition: winuser.h:2157
#define TVS_SHOWSELALWAYS
Definition: commctrl.h:3224
HMENU WINAPI CreatePopupMenu(void)
Definition: menu.c:846
#define TVS_HASLINES
Definition: commctrl.h:3220
LRESULT OnContextMenu(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
#define TVSIL_NORMAL
Definition: commctrl.h:3415
#define SendMessage
Definition: winuser.h:5709
int WINAPI SHMapPIDLToSystemImageListIndex(IShellFolder *sh, LPCITEMIDLIST pidl, int *pIndex)
Definition: iconcache.cpp:789
struct stdole::DISPPARAMS DISPPARAMS
#define TPM_LEFTBUTTON
Definition: winuser.h:2333
#define HIWORD(l)
Definition: typedefs.h:246
unsigned int ULONG
Definition: retypes.h:1
#define TVIF_STATE
Definition: commctrl.h:3241
HRESULT WINAPI SHGetFolderLocation(HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwReserved, LPITEMIDLIST *ppidl)
Definition: shellpath.c:2598
#define SHIL_SMALL
Definition: shellapi.h:183
static char * dest
Definition: rtl.c:135
#define TVIF_PARAM
Definition: commctrl.h:3240
virtual HRESULT STDMETHODCALLTYPE GetTypeInfoCount(UINT *pctinfo)
#define SID_SShellBrowser
Definition: shlguid.h:125
BOOL WINAPI ScreenToClient(_In_ HWND, _Inout_ LPPOINT)
LONG_PTR LRESULT
Definition: windef.h:209
#define E_POINTER
Definition: winerror.h:2365
#define TVHT_ONITEM
Definition: commctrl.h:3499
#define TV_INSERTSTRUCT
Definition: commctrl.h:3349
#define TreeView_Expand(hwnd, hitem, code)
Definition: commctrl.h:3392
LPARAM lParam
Definition: commctrl.h:3588
GLuint64EXT * result
Definition: glext.h:11304
LRESULT ContextMenuHack(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
ITEMIDLIST UNALIGNED * LPITEMIDLIST
Definition: shtypes.idl:41
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HMENU
Definition: ordinal.c:60
#define PT_GUID
LPARAM lParam
Definition: combotst.c:139
BOOL WINAPI TrackPopupMenu(_In_ HMENU, _In_ UINT, _In_ int, _In_ int, _Reserved_ int, _In_ HWND, _Reserved_ LPCRECT)
#define LOWORD(l)
Definition: pedump.c:82
static SHCONTF
Definition: ordinal.c:61
#define UNIMPLEMENTED
LPITEMIDLIST pidlCurrent
Definition: explorerband.h:65
#define PathIsRoot
Definition: shlwapi.h:955
#define TreeView_GetItem(hwnd, pitem)
Definition: commctrl.h:3462
#define WM_NOTIFY
Definition: richedit.h:61
static IShellFolder IShellItem **static IBindCtx LPITEMIDLIST SFGAOF
Definition: ebrowser.c:83
#define SUCCEEDED(hr)
Definition: intsafe.h:57
#define TVS_EDITLABELS
Definition: commctrl.h:3222
struct task_struct * current
Definition: linux.c:32
void DestroyExplorerBand()
#define PT_SHELLEXT
virtual HRESULT STDMETHODCALLTYPE ShowDW(BOOL fShow)
struct _PIDLDATA * LPPIDLDATA