dll/win32/browseui/explorerband.cpp

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