dlls/explorerframe/nstc.c

   1 /*
   2  * NamespaceTreeControl implementation.
   3  *
   4  * Copyright 2010 David Hedberg
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24 #define NONAMELESSUNION
  25
  26 #include "winerror.h"
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winuser.h"
  30 #include "shellapi.h"
  31 #include "commctrl.h"
  32 #include "commoncontrols.h"
  33
  34 #include "wine/list.h"
  35 #include "wine/debug.h"
  36 #include "wine/heap.h"
  37
  38 #include "explorerframe_main.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(nstc);
  41
  42 typedef struct nstc_root {
  43     IShellItem *psi;
  44     HTREEITEM htreeitem;
  45     SHCONTF enum_flags;
  46     NSTCROOTSTYLE root_style;
  47     IShellItemFilter *pif;
  48     struct list entry;
  49 } nstc_root;
  50
  51 typedef struct {
  52     INameSpaceTreeControl2 INameSpaceTreeControl2_iface;
  53     IOleWindow IOleWindow_iface;
  54     LONG ref;
  55
  56     HWND hwnd_main;
  57     HWND hwnd_tv;
  58
  59     WNDPROC tv_oldwndproc;
  60
  61     NSTCSTYLE style;
  62     NSTCSTYLE2 style2;
  63     struct list roots;
  64
  65     INameSpaceTreeControlCustomDraw *customdraw;
  66     INameSpaceTreeControlDropHandler *dragdrop;
  67     INameSpaceTreeControlEvents *events;
  68 } NSTC2Impl;
  69
  70 static const DWORD unsupported_styles =
  71     NSTCS_NOREPLACEOPEN | NSTCS_NOORDERSTREAM | NSTCS_FAVORITESMODE |
  72     NSTCS_EMPTYTEXT | NSTCS_ALLOWJUNCTIONS | NSTCS_SHOWTABSBUTTON | NSTCS_SHOWDELETEBUTTON |
  73     NSTCS_SHOWREFRESHBUTTON | NSTCS_SPRINGEXPAND | NSTCS_RICHTOOLTIP | NSTCS_NOINDENTCHECKS;
  74 static const DWORD unsupported_styles2 =
  75     NSTCS2_INTERRUPTNOTIFICATIONS | NSTCS2_SHOWNULLSPACEMENU | NSTCS2_DISPLAYPADDING |
  76     NSTCS2_DISPLAYPINNEDONLY | NTSCS2_NOSINGLETONAUTOEXPAND | NTSCS2_NEVERINSERTNONENUMERATED;
  77
  78 static inline NSTC2Impl *impl_from_INameSpaceTreeControl2(INameSpaceTreeControl2 *iface)
  79 {
  80     return CONTAINING_RECORD(iface, NSTC2Impl, INameSpaceTreeControl2_iface);
  81 }
  82
  83 static inline NSTC2Impl *impl_from_IOleWindow(IOleWindow *iface)
  84 {
  85     return CONTAINING_RECORD(iface, NSTC2Impl, IOleWindow_iface);
  86 }
  87
  88 /* Forward declarations */
  89 static LRESULT CALLBACK tv_wndproc(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam);
  90
  91 /*************************************************************************
  92 * NamespaceTree event wrappers
  93 */
  94 static HRESULT events_OnGetDefaultIconIndex(NSTC2Impl *This, IShellItem *psi,
  95                                             int *piDefaultIcon, int *piOpenIcon)
  96 {
  97     HRESULT ret;
  98     LONG refcount;
  99     if(!This->events) return E_NOTIMPL;
 100
 101     refcount = IShellItem_AddRef(psi);
 102     ret = INameSpaceTreeControlEvents_OnGetDefaultIconIndex(This->events, psi, piDefaultIcon, piOpenIcon);
 103     if(IShellItem_Release(psi) < refcount - 1)
 104         ERR("ShellItem was released by client - please file a bug.\n");
 105     return ret;
 106 }
 107
 108 static HRESULT events_OnItemAdded(NSTC2Impl *This, IShellItem *psi, BOOL fIsRoot)
 109 {
 110     HRESULT ret;
 111     LONG refcount;
 112     if(!This->events) return S_OK;
 113
 114     refcount = IShellItem_AddRef(psi);
 115     ret = INameSpaceTreeControlEvents_OnItemAdded(This->events, psi, fIsRoot);
 116     if(IShellItem_Release(psi) < refcount - 1)
 117         ERR("ShellItem was released by client - please file a bug.\n");
 118     return ret;
 119 }
 120
 121 static HRESULT events_OnItemDeleted(NSTC2Impl *This, IShellItem *psi, BOOL fIsRoot)
 122 {
 123     HRESULT ret;
 124     LONG refcount;
 125     if(!This->events) return S_OK;
 126
 127     refcount = IShellItem_AddRef(psi);
 128     ret = INameSpaceTreeControlEvents_OnItemDeleted(This->events, psi, fIsRoot);
 129     if(IShellItem_Release(psi) < refcount - 1)
 130         ERR("ShellItem was released by client - please file a bug.\n");
 131     return ret;
 132 }
 133
 134 static HRESULT events_OnBeforeExpand(NSTC2Impl *This, IShellItem *psi)
 135 {
 136     HRESULT ret;
 137     LONG refcount;
 138     if(!This->events) return S_OK;
 139
 140     refcount = IShellItem_AddRef(psi);
 141     ret = INameSpaceTreeControlEvents_OnBeforeExpand(This->events, psi);
 142     if(IShellItem_Release(psi) < refcount - 1)
 143         ERR("ShellItem was released by client - please file a bug.\n");
 144     return ret;
 145 }
 146
 147 static HRESULT events_OnAfterExpand(NSTC2Impl *This, IShellItem *psi)
 148 {
 149     HRESULT ret;
 150     LONG refcount;
 151     if(!This->events) return S_OK;
 152
 153     refcount = IShellItem_AddRef(psi);
 154     ret = INameSpaceTreeControlEvents_OnAfterExpand(This->events, psi);
 155     if(IShellItem_Release(psi) < refcount - 1)
 156         ERR("ShellItem was released by client - please file a bug.\n");
 157     return ret;
 158 }
 159
 160 static HRESULT events_OnItemClick(NSTC2Impl *This, IShellItem *psi,
 161                                   NSTCEHITTEST nstceHitTest, NSTCECLICKTYPE nstceClickType)
 162 {
 163     HRESULT ret;
 164     LONG refcount;
 165     if(!This->events) return S_OK;
 166
 167     refcount = IShellItem_AddRef(psi);
 168     ret = INameSpaceTreeControlEvents_OnItemClick(This->events, psi, nstceHitTest, nstceClickType);
 169     if(IShellItem_Release(psi) < refcount - 1)
 170         ERR("ShellItem was released by client - please file a bug.\n");
 171     return ret;
 172 }
 173
 174 static HRESULT events_OnSelectionChanged(NSTC2Impl *This, IShellItemArray *psia)
 175 {
 176     if(!This->events) return S_OK;
 177
 178     return INameSpaceTreeControlEvents_OnSelectionChanged(This->events, psia);
 179 }
 180
 181 static HRESULT events_OnKeyboardInput(NSTC2Impl *This, UINT uMsg, WPARAM wParam, LPARAM lParam)
 182 {
 183     if(!This->events) return S_OK;
 184
 185     return INameSpaceTreeControlEvents_OnKeyboardInput(This->events, uMsg, wParam, lParam);
 186 }
 187
 188 /*************************************************************************
 189  * NamespaceTree helper functions
 190  */
 191 static DWORD treeview_style_from_nstcs(NSTC2Impl *This, NSTCSTYLE nstcs,
 192                                        NSTCSTYLE nstcs_mask, DWORD *new_style)
 193 {
 194     DWORD old_style, tv_mask = 0;
 195     TRACE("%p, %x, %x, %p\n", This, nstcs, nstcs_mask, new_style);
 196
 197     if(This->hwnd_tv)
 198         old_style = GetWindowLongPtrW(This->hwnd_tv, GWL_STYLE);
 199     else
 200         old_style = /* The default */
 201             WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN |
 202             WS_TABSTOP | TVS_NOHSCROLL | TVS_NONEVENHEIGHT | TVS_INFOTIP |
 203             TVS_EDITLABELS | TVS_TRACKSELECT;
 204
 205     if(nstcs_mask & NSTCS_HASEXPANDOS)         tv_mask |= TVS_HASBUTTONS;
 206     if(nstcs_mask & NSTCS_HASLINES)            tv_mask |= TVS_HASLINES;
 207     if(nstcs_mask & NSTCS_FULLROWSELECT)       tv_mask |= TVS_FULLROWSELECT;
 208     if(nstcs_mask & NSTCS_HORIZONTALSCROLL)    tv_mask |= TVS_NOHSCROLL;
 209     if(nstcs_mask & NSTCS_ROOTHASEXPANDO)      tv_mask |= TVS_LINESATROOT;
 210     if(nstcs_mask & NSTCS_SHOWSELECTIONALWAYS) tv_mask |= TVS_SHOWSELALWAYS;
 211     if(nstcs_mask & NSTCS_NOINFOTIP)           tv_mask |= TVS_INFOTIP;
 212     if(nstcs_mask & NSTCS_EVENHEIGHT)          tv_mask |= TVS_NONEVENHEIGHT;
 213     if(nstcs_mask & NSTCS_DISABLEDRAGDROP)     tv_mask |= TVS_DISABLEDRAGDROP;
 214     if(nstcs_mask & NSTCS_NOEDITLABELS)        tv_mask |= TVS_EDITLABELS;
 215     if(nstcs_mask & NSTCS_CHECKBOXES)          tv_mask |= TVS_CHECKBOXES;
 216     if(nstcs_mask & NSTCS_SINGLECLICKEXPAND)   tv_mask |= TVS_SINGLEEXPAND;
 217
 218     *new_style = 0;
 219
 220     if(nstcs & NSTCS_HASEXPANDOS)         *new_style |= TVS_HASBUTTONS;
 221     if(nstcs & NSTCS_HASLINES)            *new_style |= TVS_HASLINES;
 222     if(nstcs & NSTCS_FULLROWSELECT)       *new_style |= TVS_FULLROWSELECT;
 223     if(!(nstcs & NSTCS_HORIZONTALSCROLL)) *new_style |= TVS_NOHSCROLL;
 224     if(nstcs & NSTCS_ROOTHASEXPANDO)      *new_style |= TVS_LINESATROOT;
 225     if(nstcs & NSTCS_SHOWSELECTIONALWAYS) *new_style |= TVS_SHOWSELALWAYS;
 226     if(!(nstcs & NSTCS_NOINFOTIP))        *new_style |= TVS_INFOTIP;
 227     if(!(nstcs & NSTCS_EVENHEIGHT))       *new_style |= TVS_NONEVENHEIGHT;
 228     if(nstcs & NSTCS_DISABLEDRAGDROP)     *new_style |= TVS_DISABLEDRAGDROP;
 229     if(!(nstcs & NSTCS_NOEDITLABELS))     *new_style |= TVS_EDITLABELS;
 230     if(nstcs & NSTCS_CHECKBOXES)          *new_style |= TVS_CHECKBOXES;
 231     if(nstcs & NSTCS_SINGLECLICKEXPAND)   *new_style |= TVS_SINGLEEXPAND;
 232
 233     *new_style = (old_style & ~tv_mask) | (*new_style & tv_mask);
 234
 235     TRACE("old: %08x, new: %08x\n", old_style, *new_style);
 236
 237     return old_style^*new_style;
 238 }
 239
 240 static IShellItem *shellitem_from_treeitem(NSTC2Impl *This, HTREEITEM hitem)
 241 {
 242     TVITEMEXW tvi;
 243
 244     tvi.mask = TVIF_PARAM;
 245     tvi.lParam = 0;
 246     tvi.hItem = hitem;
 247
 248     SendMessageW(This->hwnd_tv, TVM_GETITEMW, 0, (LPARAM)&tvi);
 249
 250     TRACE("ShellItem: %p\n", (void*)tvi.lParam);
 251     return (IShellItem*)tvi.lParam;
 252 }
 253
 254 /* Returns the root that the given treeitem belongs to. */
 255 static nstc_root *root_for_treeitem(NSTC2Impl *This, HTREEITEM hitem)
 256 {
 257     HTREEITEM tmp, hroot = hitem;
 258     nstc_root *root;
 259
 260     /* Work our way up the hierarchy */
 261     for(tmp = hitem; tmp != NULL; hroot = tmp?tmp:hroot)
 262         tmp = (HTREEITEM)SendMessageW(This->hwnd_tv, TVM_GETNEXTITEM, TVGN_PARENT, (LPARAM)hroot);
 263
 264     /* Search through the list of roots for a match */
 265     LIST_FOR_EACH_ENTRY(root, &This->roots, nstc_root, entry)
 266         if(root->htreeitem == hroot)
 267             break;
 268
 269     TRACE("root is %p\n", root);
 270     return root;
 271 }
 272
 273 /* Find a shellitem in the tree, starting from the given node. */
 274 static HTREEITEM search_for_shellitem(NSTC2Impl *This, HTREEITEM node,
 275                                       IShellItem *psi)
 276 {
 277     IShellItem *psi_node;
 278     HTREEITEM next, result = NULL;
 279     HRESULT hr;
 280     int cmpo;
 281     TRACE("%p, %p, %p\n", This, node, psi);
 282
 283     /* Check this node */
 284     psi_node = shellitem_from_treeitem(This, node);
 285     hr = IShellItem_Compare(psi, psi_node, SICHINT_DISPLAY, &cmpo);
 286     if(hr == S_OK)
 287         return node;
 288
 289     /* Any children? */
 290     next = (HTREEITEM)SendMessageW(This->hwnd_tv, TVM_GETNEXTITEM,
 291                                    TVGN_CHILD, (LPARAM)node);
 292     if(next)
 293     {
 294         result = search_for_shellitem(This, next, psi);
 295         if(result) return result;
 296     }
 297
 298     /* Try our next sibling. */
 299     next = (HTREEITEM)SendMessageW(This->hwnd_tv, TVM_GETNEXTITEM,
 300                                    TVGN_NEXT, (LPARAM)node);
 301     if(next)
 302         result = search_for_shellitem(This, next, psi);
 303
 304     return result;
 305 }
 306
 307 static HTREEITEM treeitem_from_shellitem(NSTC2Impl *This, IShellItem *psi)
 308 {
 309     HTREEITEM root;
 310     TRACE("%p, %p\n", This, psi);
 311
 312     root = (HTREEITEM)SendMessageW(This->hwnd_tv, TVM_GETNEXTITEM,
 313                                    TVGN_ROOT, 0);
 314     if(!root)
 315         return NULL;
 316
 317     return search_for_shellitem(This, root, psi);
 318 }
 319
 320 static int get_icon(LPCITEMIDLIST lpi, UINT extra_flags)
 321 {
 322     SHFILEINFOW sfi;
 323     UINT flags = SHGFI_PIDL | SHGFI_SYSICONINDEX | SHGFI_SMALLICON;
 324     IImageList *list;
 325
 326     list = (IImageList *)SHGetFileInfoW((LPCWSTR)lpi, 0 ,&sfi, sizeof(SHFILEINFOW), flags | extra_flags);
 327     if (list) IImageList_Release(list);
 328     return sfi.iIcon;
 329 }
 330
 331 /* Insert a shellitem into the given place in the tree and return the
 332    resulting treeitem. */
 333 static HTREEITEM insert_shellitem(NSTC2Impl *This, IShellItem *psi,
 334                                   HTREEITEM hParent, HTREEITEM hInsertAfter)
 335 {
 336     TVINSERTSTRUCTW tvins;
 337     TVITEMEXW *tvi = &tvins.u.itemex;
 338     HTREEITEM hinserted;
 339     TRACE("%p (%p, %p)\n", psi, hParent, hInsertAfter);
 340
 341     tvi->mask = TVIF_PARAM | TVIF_CHILDREN | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_TEXT;
 342     tvi->cChildren = I_CHILDRENCALLBACK;
 343     tvi->iImage = tvi->iSelectedImage = I_IMAGECALLBACK;
 344     tvi->pszText = LPSTR_TEXTCALLBACKW;
 345
 346     /* Every treeitem contains a pointer to the corresponding ShellItem. */
 347     tvi->lParam = (LPARAM)psi;
 348     tvins.hParent = hParent;
 349     tvins.hInsertAfter = hInsertAfter;
 350
 351     hinserted = (HTREEITEM)SendMessageW(This->hwnd_tv, TVM_INSERTITEMW, 0,
 352                                         (LPARAM)(LPTVINSERTSTRUCTW)&tvins);
 353     if(hinserted)
 354         IShellItem_AddRef(psi);
 355
 356     return hinserted;
 357 }
 358
 359 /* Enumerates the children of the folder represented by hitem
 360  * according to the settings for the root, and adds them to the
 361  * treeview. Returns the number of children added. */
 362 static UINT fill_sublevel(NSTC2Impl *This, HTREEITEM hitem)
 363 {
 364     IShellItem *psiParent = shellitem_from_treeitem(This, hitem);
 365     nstc_root *root = root_for_treeitem(This, hitem);
 366     LPITEMIDLIST pidl_parent;
 367     IShellFolder *psf;
 368     IEnumIDList *peidl;
 369     UINT added = 0;
 370     HRESULT hr;
 371
 372     hr = SHGetIDListFromObject((IUnknown*)psiParent, &pidl_parent);
 373     if(SUCCEEDED(hr))
 374     {
 375         hr = IShellItem_BindToHandler(psiParent, NULL, &BHID_SFObject, &IID_IShellFolder, (void**)&psf);
 376         if(SUCCEEDED(hr))
 377         {
 378             hr = IShellFolder_EnumObjects(psf, NULL, root->enum_flags, &peidl);
 379             if(SUCCEEDED(hr))
 380             {
 381                 LPITEMIDLIST pidl;
 382                 IShellItem *psi;
 383                 ULONG fetched;
 384
 385                 while( S_OK == IEnumIDList_Next(peidl, 1, &pidl, &fetched) )
 386                 {
 387                     hr = SHCreateShellItem(NULL, psf , pidl, &psi);
 388                     ILFree(pidl);
 389                     if(SUCCEEDED(hr))
 390                     {
 391                         if(insert_shellitem(This, psi, hitem, NULL))
 392                         {
 393                             events_OnItemAdded(This, psi, FALSE);
 394                             added++;
 395                         }
 396
 397                         IShellItem_Release(psi);
 398                     }
 399                     else
 400                         ERR("SHCreateShellItem failed with 0x%08x\n", hr);
 401                 }
 402                 IEnumIDList_Release(peidl);
 403             }
 404             else
 405                 ERR("EnumObjects failed with 0x%08x\n", hr);
 406
 407             IShellFolder_Release(psf);
 408         }
 409         else
 410             ERR("BindToHandler failed with 0x%08x\n", hr);
 411
 412         ILFree(pidl_parent);
 413     }
 414     else
 415         ERR("SHGetIDListFromObject failed with 0x%08x\n", hr);
 416
 417     return added;
 418 }
 419
 420 static HTREEITEM get_selected_treeitem(NSTC2Impl *This)
 421 {
 422     return (HTREEITEM)SendMessageW(This->hwnd_tv, TVM_GETNEXTITEM, TVGN_CARET, 0);
 423 }
 424
 425 static IShellItem *get_selected_shellitem(NSTC2Impl *This)
 426 {
 427     return shellitem_from_treeitem(This, get_selected_treeitem(This));
 428 }
 429
 430 static void collapse_all(NSTC2Impl *This, HTREEITEM node)
 431 {
 432     HTREEITEM next;
 433
 434     /* Collapse this node first, and then first child/next sibling. */
 435     SendMessageW(This->hwnd_tv, TVM_EXPAND, TVE_COLLAPSE, (LPARAM)node);
 436
 437     next = (HTREEITEM)SendMessageW(This->hwnd_tv, TVM_GETNEXTITEM, TVGN_CHILD, (LPARAM)node);
 438     if(next) collapse_all(This, next);
 439
 440     next = (HTREEITEM)SendMessageW(This->hwnd_tv, TVM_GETNEXTITEM, TVGN_NEXT, (LPARAM)node);
 441     if(next) collapse_all(This, next);
 442 }
 443
 444 static HTREEITEM treeitem_from_point(NSTC2Impl *This, const POINT *pt, UINT *hitflag)
 445 {
 446     TVHITTESTINFO tviht;
 447     tviht.pt.x = pt->x;
 448     tviht.pt.y = pt->y;
 449     tviht.hItem = NULL;
 450
 451     SendMessageW(This->hwnd_tv, TVM_HITTEST, 0, (LPARAM)&tviht);
 452     if(hitflag) *hitflag = tviht.flags;
 453     return tviht.hItem;
 454 }
 455
 456 /*************************************************************************
 457  * NamespaceTree window functions
 458  */
 459 static LRESULT create_namespacetree(HWND hWnd, CREATESTRUCTW *crs)
 460 {
 461     NSTC2Impl *This = crs->lpCreateParams;
 462     HIMAGELIST ShellSmallIconList;
 463     DWORD treeview_style, treeview_ex_style;
 464
 465     TRACE("%p (%p)\n", This, crs);
 466     SetWindowLongPtrW(hWnd, GWLP_USERDATA, (LPARAM)This);
 467     This->hwnd_main = hWnd;
 468
 469     treeview_style_from_nstcs(This, This->style, 0xFFFFFFFF, &treeview_style);
 470
 471     This->hwnd_tv = CreateWindowExW(0, WC_TREEVIEWW, NULL, treeview_style,
 472                                     0, 0, crs->cx, crs->cy,
 473                                     hWnd, NULL, explorerframe_hinstance, NULL);
 474
 475     if(!This->hwnd_tv)
 476     {
 477         ERR("Failed to create treeview!\n");
 478         return HRESULT_FROM_WIN32(GetLastError());
 479     }
 480
 481     treeview_ex_style = TVS_EX_DRAWIMAGEASYNC | TVS_EX_RICHTOOLTIP |
 482         TVS_EX_DOUBLEBUFFER | TVS_EX_NOSINGLECOLLAPSE;
 483
 484     if(This->style & NSTCS_AUTOHSCROLL)
 485         treeview_ex_style |= TVS_EX_AUTOHSCROLL;
 486     if(This->style & NSTCS_FADEINOUTEXPANDOS)
 487         treeview_ex_style |= TVS_EX_FADEINOUTEXPANDOS;
 488     if(This->style & NSTCS_PARTIALCHECKBOXES)
 489         treeview_ex_style |= TVS_EX_PARTIALCHECKBOXES;
 490     if(This->style & NSTCS_EXCLUSIONCHECKBOXES)
 491         treeview_ex_style |= TVS_EX_EXCLUSIONCHECKBOXES;
 492     if(This->style & NSTCS_DIMMEDCHECKBOXES)
 493         treeview_ex_style |= TVS_EX_DIMMEDCHECKBOXES;
 494
 495     SendMessageW(This->hwnd_tv, TVM_SETEXTENDEDSTYLE, treeview_ex_style, 0xffff);
 496
 497     if(Shell_GetImageLists(NULL, &ShellSmallIconList))
 498     {
 499         SendMessageW(This->hwnd_tv, TVM_SETIMAGELIST,
 500                      (WPARAM)TVSIL_NORMAL, (LPARAM)ShellSmallIconList);
 501     }
 502     else
 503     {
 504         ERR("Failed to get the System Image List.\n");
 505     }
 506
 507     INameSpaceTreeControl2_AddRef(&This->INameSpaceTreeControl2_iface);
 508
 509     /* Subclass the treeview to get the keyboard events. */
 510     This->tv_oldwndproc = (WNDPROC)SetWindowLongPtrW(This->hwnd_tv, GWLP_WNDPROC,
 511                                                      (ULONG_PTR)tv_wndproc);
 512     if(This->tv_oldwndproc)
 513         SetPropW(This->hwnd_tv, L"PROP_THIS", This);
 514
 515     return TRUE;
 516 }
 517
 518 static LRESULT resize_namespacetree(NSTC2Impl *This)
 519 {
 520     RECT rc;
 521     TRACE("%p\n", This);
 522
 523     GetClientRect(This->hwnd_main, &rc);
 524     MoveWindow(This->hwnd_tv, 0, 0, rc.right-rc.left, rc.bottom-rc.top, TRUE);
 525
 526     return TRUE;
 527 }
 528
 529 static LRESULT destroy_namespacetree(NSTC2Impl *This)
 530 {
 531     TRACE("%p\n", This);
 532
 533     /* Undo the subclassing */
 534     if(This->tv_oldwndproc)
 535     {
 536         SetWindowLongPtrW(This->hwnd_tv, GWLP_WNDPROC, (ULONG_PTR)This->tv_oldwndproc);
 537         RemovePropW(This->hwnd_tv, L"PROP_THIS");
 538     }
 539
 540     INameSpaceTreeControl2_RemoveAllRoots(&This->INameSpaceTreeControl2_iface);
 541
 542     /* This reference was added in create_namespacetree */
 543     INameSpaceTreeControl2_Release(&This->INameSpaceTreeControl2_iface);
 544     return TRUE;
 545 }
 546
 547 static LRESULT on_tvn_deleteitemw(NSTC2Impl *This, LPARAM lParam)
 548 {
 549     NMTREEVIEWW *nmtv = (NMTREEVIEWW*)lParam;
 550     TRACE("%p\n", This);
 551
 552     IShellItem_Release((IShellItem*)nmtv->itemOld.lParam);
 553     return TRUE;
 554 }
 555
 556 static LRESULT on_tvn_getdispinfow(NSTC2Impl *This, LPARAM lParam)
 557 {
 558     NMTVDISPINFOW *dispinfo = (NMTVDISPINFOW*)lParam;
 559     TVITEMEXW *item = (TVITEMEXW*)&dispinfo->item;
 560     IShellItem *psi = shellitem_from_treeitem(This, item->hItem);
 561     HRESULT hr;
 562
 563     TRACE("%p, %p (mask: %x)\n", This, dispinfo, item->mask);
 564
 565     if(item->mask & TVIF_CHILDREN)
 566     {
 567         SFGAOF sfgao;
 568
 569         hr = IShellItem_GetAttributes(psi, SFGAO_HASSUBFOLDER, &sfgao);
 570         if(SUCCEEDED(hr))
 571             item->cChildren = (sfgao & SFGAO_HASSUBFOLDER)?1:0;
 572         else
 573             item->cChildren = 1;
 574
 575         item->mask |= TVIF_DI_SETITEM;
 576     }
 577
 578     if(item->mask & (TVIF_IMAGE|TVIF_SELECTEDIMAGE))
 579     {
 580         LPITEMIDLIST pidl;
 581
 582         hr = events_OnGetDefaultIconIndex(This, psi, &item->iImage, &item->iSelectedImage);
 583         if(FAILED(hr))
 584         {
 585             hr = SHGetIDListFromObject((IUnknown*)psi, &pidl);
 586             if(SUCCEEDED(hr))
 587             {
 588                 item->iImage = item->iSelectedImage = get_icon(pidl, 0);
 589                 item->mask |= TVIF_DI_SETITEM;
 590                 ILFree(pidl);
 591             }
 592             else
 593                 ERR("Failed to get IDList (%08x).\n", hr);
 594         }
 595     }
 596
 597     if(item->mask & TVIF_TEXT)
 598     {
 599         LPWSTR display_name;
 600
 601         hr = IShellItem_GetDisplayName(psi, SIGDN_NORMALDISPLAY, &display_name);
 602         if(SUCCEEDED(hr))
 603         {
 604             lstrcpynW(item->pszText, display_name, MAX_PATH);
 605             item->mask |= TVIF_DI_SETITEM;
 606             CoTaskMemFree(display_name);
 607         }
 608         else
 609             ERR("Failed to get display name (%08x).\n", hr);
 610     }
 611
 612     return TRUE;
 613 }
 614
 615 static BOOL treenode_has_subfolders(NSTC2Impl *This, HTREEITEM node)
 616 {
 617     return SendMessageW(This->hwnd_tv, TVM_GETNEXTITEM, TVGN_CHILD, (LPARAM)node);
 618 }
 619
 620 static LRESULT on_tvn_itemexpandingw(NSTC2Impl *This, LPARAM lParam)
 621 {
 622     NMTREEVIEWW *nmtv = (NMTREEVIEWW*)lParam;
 623     IShellItem *psi;
 624     TRACE("%p\n", This);
 625
 626     psi = shellitem_from_treeitem(This, nmtv->itemNew.hItem);
 627     events_OnBeforeExpand(This, psi);
 628
 629     if(!treenode_has_subfolders(This, nmtv->itemNew.hItem))
 630     {
 631         /* The node has no children, try to find some */
 632         if(!fill_sublevel(This, nmtv->itemNew.hItem))
 633         {
 634             TVITEMEXW tvi;
 635             /* Failed to enumerate any children, remove the expando
 636              * (if any). */
 637             tvi.hItem = nmtv->itemNew.hItem;
 638             tvi.mask = TVIF_CHILDREN;
 639             tvi.cChildren = 0;
 640             SendMessageW(This->hwnd_tv, TVM_SETITEMW, 0, (LPARAM)&tvi);
 641
 642             return TRUE;
 643         }
 644     }
 645     return FALSE;
 646 }
 647
 648 static LRESULT on_tvn_itemexpandedw(NSTC2Impl *This, LPARAM lParam)
 649 {
 650     NMTREEVIEWW *nmtv = (NMTREEVIEWW*)lParam;
 651     IShellItem *psi;
 652     TRACE("%p\n", This);
 653
 654     psi = shellitem_from_treeitem(This, nmtv->itemNew.hItem);
 655     events_OnAfterExpand(This, psi);
 656     return TRUE;
 657 }
 658
 659 static LRESULT on_tvn_selchangedw(NSTC2Impl *This, LPARAM lParam)
 660 {
 661     NMTREEVIEWW *nmtv = (NMTREEVIEWW*)lParam;
 662     IShellItemArray *psia;
 663     IShellItem *psi;
 664     HRESULT hr;
 665     TRACE("%p\n", This);
 666
 667     /* Note: Only supports one selected item. */
 668     psi = shellitem_from_treeitem(This, nmtv->itemNew.hItem);
 669     hr = SHCreateShellItemArrayFromShellItem(psi, &IID_IShellItemArray, (void**)&psia);
 670     if(SUCCEEDED(hr))
 671     {
 672         events_OnSelectionChanged(This, psia);
 673         IShellItemArray_Release(psia);
 674     }
 675
 676     return TRUE;
 677 }
 678
 679 static LRESULT on_nm_click(NSTC2Impl *This, NMHDR *nmhdr)
 680 {
 681     TVHITTESTINFO tvhit;
 682     IShellItem *psi;
 683
 684     TRACE("%p (%p)\n", This, nmhdr);
 685
 686     GetCursorPos(&tvhit.pt);
 687     ScreenToClient(This->hwnd_tv, &tvhit.pt);
 688     SendMessageW(This->hwnd_tv, TVM_HITTEST, 0, (LPARAM)&tvhit);
 689
 690     if(tvhit.flags & (TVHT_NOWHERE|TVHT_ABOVE|TVHT_BELOW))
 691         return TRUE;
 692
 693     /* TVHT_ maps onto the corresponding NSTCEHT_ */
 694     psi = shellitem_from_treeitem(This, tvhit.hItem);
 695     return FAILED(events_OnItemClick(This, psi, tvhit.flags, NSTCECT_LBUTTON));
 696 }
 697
 698 static LRESULT on_wm_mbuttonup(NSTC2Impl *This, WPARAM wParam, LPARAM lParam)
 699 {
 700     TVHITTESTINFO tvhit;
 701     IShellItem *psi;
 702     HRESULT hr;
 703     TRACE("%p (%lx, %lx)\n", This, wParam, lParam);
 704
 705     tvhit.pt.x = (int)(short)LOWORD(lParam);
 706     tvhit.pt.y = (int)(short)HIWORD(lParam);
 707
 708     SendMessageW(This->hwnd_tv, TVM_HITTEST, 0, (LPARAM)&tvhit);
 709
 710     /* Seems to generate only ONITEM and ONITEMICON */
 711     if( !(tvhit.flags & (TVHT_ONITEM|TVHT_ONITEMICON)) )
 712         return FALSE;
 713
 714     psi = shellitem_from_treeitem(This, tvhit.hItem);
 715     hr = events_OnItemClick(This, psi, tvhit.flags, NSTCECT_MBUTTON);
 716
 717     if(SUCCEEDED(hr))
 718         return FALSE;
 719     else
 720         return TRUE;
 721 }
 722
 723 static LRESULT on_kbd_event(NSTC2Impl *This, UINT uMsg, WPARAM wParam, LPARAM lParam)
 724 {
 725     IShellItem *psi;
 726     HTREEITEM hitem;
 727     TRACE("%p : %d, %lx, %lx\n", This, uMsg, wParam, lParam);
 728
 729     /* Handled by the client? */
 730     if(FAILED(events_OnKeyboardInput(This, uMsg, wParam, lParam)))
 731         return TRUE;
 732
 733     if(uMsg == WM_KEYDOWN)
 734     {
 735         switch(wParam)
 736         {
 737         case VK_DELETE:
 738             psi = get_selected_shellitem(This);
 739             FIXME("Deletion of file requested (shellitem: %p).\n", psi);
 740             return TRUE;
 741
 742         case VK_F2:
 743             hitem = get_selected_treeitem(This);
 744             SendMessageW(This->hwnd_tv, TVM_EDITLABELW, 0, (LPARAM)hitem);
 745             return TRUE;
 746         }
 747     }
 748
 749     /* Let the TreeView handle the key */
 750     return FALSE;
 751 }
 752
 753 static LRESULT CALLBACK tv_wndproc(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
 754 {
 755     NSTC2Impl *This = (NSTC2Impl*)GetPropW(hWnd, L"PROP_THIS");
 756
 757     switch(uMessage) {
 758     case WM_KEYDOWN:
 759     case WM_KEYUP:
 760     case WM_CHAR:
 761     case WM_SYSKEYDOWN:
 762     case WM_SYSKEYUP:
 763     case WM_SYSCHAR:
 764         if(on_kbd_event(This, uMessage, wParam, lParam))
 765             return TRUE;
 766         break;
 767
 768     case WM_MBUTTONUP:        return on_wm_mbuttonup(This, wParam, lParam);
 769     }
 770
 771     /* Pass the message on to the treeview */
 772     return CallWindowProcW(This->tv_oldwndproc, hWnd, uMessage, wParam, lParam);
 773 }
 774
 775 static LRESULT CALLBACK NSTC2_WndProc(HWND hWnd, UINT uMessage,
 776                                       WPARAM wParam, LPARAM lParam)
 777 {
 778     NSTC2Impl *This = (NSTC2Impl*)GetWindowLongPtrW(hWnd, GWLP_USERDATA);
 779     NMHDR *nmhdr;
 780
 781     switch(uMessage)
 782     {
 783     case WM_NCCREATE:         return create_namespacetree(hWnd, (CREATESTRUCTW*)lParam);
 784     case WM_SIZE:             return resize_namespacetree(This);
 785     case WM_DESTROY:          return destroy_namespacetree(This);
 786     case WM_NOTIFY:
 787         nmhdr = (NMHDR*)lParam;
 788         switch(nmhdr->code)
 789         {
 790         case NM_CLICK:            return on_nm_click(This, nmhdr);
 791         case TVN_DELETEITEMW:     return on_tvn_deleteitemw(This, lParam);
 792         case TVN_GETDISPINFOW:    return on_tvn_getdispinfow(This, lParam);
 793         case TVN_ITEMEXPANDINGW:  return on_tvn_itemexpandingw(This, lParam);
 794         case TVN_ITEMEXPANDEDW:   return on_tvn_itemexpandedw(This, lParam);
 795         case TVN_SELCHANGEDW:     return on_tvn_selchangedw(This, lParam);
 796         default:                  break;
 797         }
 798         break;
 799     default:                  return DefWindowProcW(hWnd, uMessage, wParam, lParam);
 800     }
 801     return 0;
 802 }
 803
 804 /**************************************************************************
 805  * INameSpaceTreeControl2 Implementation
 806  */
 807 static HRESULT WINAPI NSTC2_fnQueryInterface(INameSpaceTreeControl2* iface,
 808                                              REFIID riid,
 809                                              void **ppvObject)
 810 {
 811     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
 812     TRACE("%p (%s, %p)\n", This, debugstr_guid(riid), ppvObject);
 813
 814     *ppvObject = NULL;
 815     if(IsEqualIID(riid, &IID_INameSpaceTreeControl2) ||
 816        IsEqualIID(riid, &IID_INameSpaceTreeControl) ||
 817        IsEqualIID(riid, &IID_IUnknown))
 818     {
 819         *ppvObject = &This->INameSpaceTreeControl2_iface;
 820     }
 821     else if(IsEqualIID(riid, &IID_IOleWindow))
 822     {
 823         *ppvObject = &This->IOleWindow_iface;
 824     }
 825
 826     if(*ppvObject)
 827     {
 828         IUnknown_AddRef((IUnknown*)*ppvObject);
 829         return S_OK;
 830     }
 831
 832     return E_NOINTERFACE;
 833 }
 834
 835 static ULONG WINAPI NSTC2_fnAddRef(INameSpaceTreeControl2* iface)
 836 {
 837     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
 838     LONG ref = InterlockedIncrement(&This->ref);
 839
 840     TRACE("%p - ref %d\n", This, ref);
 841
 842     return ref;
 843 }
 844
 845 static ULONG WINAPI NSTC2_fnRelease(INameSpaceTreeControl2* iface)
 846 {
 847     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
 848     LONG ref = InterlockedDecrement(&This->ref);
 849
 850     TRACE("%p - ref: %d\n", This, ref);
 851
 852     if(!ref)
 853     {
 854         TRACE("Freeing.\n");
 855         heap_free(This);
 856         EFRAME_UnlockModule();
 857     }
 858
 859     return ref;
 860 }
 861
 862 static HRESULT WINAPI NSTC2_fnInitialize(INameSpaceTreeControl2* iface,
 863                                          HWND hwndParent,
 864                                          RECT *prc,
 865                                          NSTCSTYLE nstcsFlags)
 866 {
 867     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
 868     WNDCLASSW wc;
 869     DWORD window_style, window_ex_style;
 870     INITCOMMONCONTROLSEX icex;
 871     RECT rc;
 872     static const WCHAR NSTC2_CLASS_NAME[] = L"NamespaceTreeControl";
 873
 874     TRACE("%p (%p, %p, %x)\n", This, hwndParent, prc, nstcsFlags);
 875
 876     if(nstcsFlags & unsupported_styles)
 877         FIXME("0x%08x contains the unsupported style(s) 0x%08x\n",
 878               nstcsFlags, nstcsFlags & unsupported_styles);
 879
 880     This->style = nstcsFlags;
 881
 882     icex.dwSize = sizeof( icex );
 883     icex.dwICC = ICC_TREEVIEW_CLASSES;
 884     InitCommonControlsEx( &icex );
 885
 886     if(!GetClassInfoW(explorerframe_hinstance, NSTC2_CLASS_NAME, &wc))
 887     {
 888         wc.style            = CS_HREDRAW | CS_VREDRAW;
 889         wc.lpfnWndProc      = NSTC2_WndProc;
 890         wc.cbClsExtra       = 0;
 891         wc.cbWndExtra       = 0;
 892         wc.hInstance        = explorerframe_hinstance;
 893         wc.hIcon            = 0;
 894         wc.hCursor          = LoadCursorW(0, (LPWSTR)IDC_ARROW);
 895         wc.hbrBackground    = (HBRUSH)(COLOR_WINDOW + 1);
 896         wc.lpszMenuName     = NULL;
 897         wc.lpszClassName    = NSTC2_CLASS_NAME;
 898
 899         if (!RegisterClassW(&wc)) return E_FAIL;
 900     }
 901
 902     /* NSTCS_TABSTOP and NSTCS_BORDER affects the host window */
 903     window_style = WS_VISIBLE | WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS |
 904         (nstcsFlags & NSTCS_BORDER ? WS_BORDER : 0);
 905     window_ex_style = nstcsFlags & NSTCS_TABSTOP ? WS_EX_CONTROLPARENT : 0;
 906
 907     if(prc)
 908         rc = *prc;
 909     else
 910         SetRectEmpty(&rc);
 911
 912     This->hwnd_main = CreateWindowExW(window_ex_style, NSTC2_CLASS_NAME, NULL, window_style,
 913                                       rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top,
 914                                       hwndParent, 0, explorerframe_hinstance, This);
 915
 916     if(!This->hwnd_main)
 917     {
 918         ERR("Failed to create the window.\n");
 919         return HRESULT_FROM_WIN32(GetLastError());
 920     }
 921
 922     return S_OK;
 923 }
 924
 925 static HRESULT WINAPI NSTC2_fnTreeAdvise(INameSpaceTreeControl2* iface, IUnknown *handler, DWORD *cookie)
 926 {
 927     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
 928
 929     TRACE("%p (%p, %p)\n", This, handler, cookie);
 930
 931     *cookie = 0;
 932
 933     /* Only one client supported */
 934     if (This->events || This->customdraw || This->dragdrop)
 935         return E_FAIL;
 936
 937     /* FIXME: request INameSpaceTreeAccessible too */
 938     IUnknown_QueryInterface(handler, &IID_INameSpaceTreeControlEvents, (void**)&This->events);
 939     IUnknown_QueryInterface(handler, &IID_INameSpaceTreeControlCustomDraw, (void**)&This->customdraw);
 940     IUnknown_QueryInterface(handler, &IID_INameSpaceTreeControlDropHandler, (void**)&This->dragdrop);
 941
 942     if (This->events || This->customdraw || This->dragdrop)
 943         *cookie = 1;
 944
 945     return *cookie ? S_OK : E_FAIL;
 946 }
 947
 948 static HRESULT WINAPI NSTC2_fnTreeUnadvise(INameSpaceTreeControl2* iface, DWORD cookie)
 949 {
 950     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
 951
 952     TRACE("%p (%x)\n", This, cookie);
 953
 954     /* The cookie is ignored. */
 955
 956     if (This->events)
 957     {
 958         INameSpaceTreeControlEvents_Release(This->events);
 959         This->events = NULL;
 960     }
 961
 962     if (This->customdraw)
 963     {
 964         INameSpaceTreeControlCustomDraw_Release(This->customdraw);
 965         This->customdraw = NULL;
 966     }
 967
 968     if (This->dragdrop)
 969     {
 970         INameSpaceTreeControlDropHandler_Release(This->dragdrop);
 971         This->dragdrop = NULL;
 972     }
 973
 974     return S_OK;
 975 }
 976
 977 static HRESULT WINAPI NSTC2_fnInsertRoot(INameSpaceTreeControl2* iface,
 978                                          int iIndex,
 979                                          IShellItem *psiRoot,
 980                                          SHCONTF grfEnumFlags,
 981                                          NSTCROOTSTYLE grfRootStyle,
 982                                          IShellItemFilter *pif)
 983 {
 984     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
 985     nstc_root *new_root;
 986     struct list *add_after_entry;
 987     HTREEITEM add_after_hitem;
 988     int i;
 989
 990     TRACE("%p, %d, %p, %x, %x, %p\n", This, iIndex, psiRoot, grfEnumFlags, grfRootStyle, pif);
 991
 992     new_root = heap_alloc(sizeof(*new_root));
 993     if(!new_root)
 994         return E_OUTOFMEMORY;
 995
 996     new_root->psi = psiRoot;
 997     new_root->enum_flags = grfEnumFlags;
 998     new_root->root_style = grfRootStyle;
 999     new_root->pif = pif;
1000
1001     /* We want to keep the roots in the internal list and in the
1002      * treeview in the same order. */
1003     add_after_entry = &This->roots;
1004     for(i = 0; i < max(0, iIndex) && list_next(&This->roots, add_after_entry); i++)
1005         add_after_entry = list_next(&This->roots, add_after_entry);
1006
1007     if(add_after_entry == &This->roots)
1008         add_after_hitem = TVI_FIRST;
1009     else
1010         add_after_hitem = LIST_ENTRY(add_after_entry, nstc_root, entry)->htreeitem;
1011
1012     new_root->htreeitem = insert_shellitem(This, psiRoot, TVI_ROOT, add_after_hitem);
1013     if(!new_root->htreeitem)
1014     {
1015         WARN("Failed to add the root.\n");
1016         heap_free(new_root);
1017         return E_FAIL;
1018     }
1019
1020     list_add_after(add_after_entry, &new_root->entry);
1021     events_OnItemAdded(This, psiRoot, TRUE);
1022
1023     if(grfRootStyle & NSTCRS_HIDDEN)
1024     {
1025         TVITEMEXW tvi;
1026         tvi.mask = TVIF_STATEEX;
1027         tvi.uStateEx = TVIS_EX_FLAT;
1028         tvi.hItem = new_root->htreeitem;
1029
1030         SendMessageW(This->hwnd_tv, TVM_SETITEMW, 0, (LPARAM)&tvi);
1031     }
1032
1033     if(grfRootStyle & NSTCRS_EXPANDED)
1034         SendMessageW(This->hwnd_tv, TVM_EXPAND, TVE_EXPAND,
1035                      (LPARAM)new_root->htreeitem);
1036
1037     return S_OK;
1038 }
1039
1040 static HRESULT WINAPI NSTC2_fnAppendRoot(INameSpaceTreeControl2* iface,
1041                                          IShellItem *psiRoot,
1042                                          SHCONTF grfEnumFlags,
1043                                          NSTCROOTSTYLE grfRootStyle,
1044                                          IShellItemFilter *pif)
1045 {
1046     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
1047     UINT root_count;
1048     TRACE("%p, %p, %x, %x, %p\n",
1049           This, psiRoot, grfEnumFlags, grfRootStyle, pif);
1050
1051     root_count = list_count(&This->roots);
1052
1053     return INameSpaceTreeControl2_InsertRoot(iface, root_count, psiRoot, grfEnumFlags, grfRootStyle, pif);
1054 }
1055
1056 static HRESULT WINAPI NSTC2_fnRemoveRoot(INameSpaceTreeControl2* iface,
1057                                          IShellItem *psiRoot)
1058 {
1059     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
1060     nstc_root *cursor, *root = NULL;
1061     TRACE("%p (%p)\n", This, psiRoot);
1062
1063     if(!psiRoot)
1064         return E_NOINTERFACE;
1065
1066     LIST_FOR_EACH_ENTRY(cursor, &This->roots, nstc_root, entry)
1067     {
1068         HRESULT hr;
1069         int order;
1070         hr = IShellItem_Compare(psiRoot, cursor->psi, SICHINT_DISPLAY, &order);
1071         if(hr == S_OK)
1072         {
1073             root = cursor;
1074             break;
1075         }
1076     }
1077
1078     TRACE("root %p\n", root);
1079     if(root)
1080     {
1081         events_OnItemDeleted(This, root->psi, TRUE);
1082         SendMessageW(This->hwnd_tv, TVM_DELETEITEM, 0, (LPARAM)root->htreeitem);
1083         list_remove(&root->entry);
1084         heap_free(root);
1085         return S_OK;
1086     }
1087     else
1088     {
1089         WARN("No matching root found.\n");
1090         return E_FAIL;
1091     }
1092 }
1093
1094 static HRESULT WINAPI NSTC2_fnRemoveAllRoots(INameSpaceTreeControl2* iface)
1095 {
1096     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
1097     nstc_root *cur1, *cur2;
1098
1099     TRACE("%p\n", This);
1100
1101     if (list_empty(&This->roots))
1102         return E_INVALIDARG;
1103
1104     LIST_FOR_EACH_ENTRY_SAFE(cur1, cur2, &This->roots, nstc_root, entry)
1105         INameSpaceTreeControl2_RemoveRoot(iface, cur1->psi);
1106
1107     return S_OK;
1108 }
1109
1110 static HRESULT WINAPI NSTC2_fnGetRootItems(INameSpaceTreeControl2* iface,
1111                                            IShellItemArray **ppsiaRootItems)
1112 {
1113     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
1114     IShellFolder *psf;
1115     LPITEMIDLIST *array;
1116     nstc_root *root;
1117     UINT count, i;
1118     HRESULT hr;
1119     TRACE("%p (%p)\n", This, ppsiaRootItems);
1120
1121     count = list_count(&This->roots);
1122
1123     if(!count)
1124         return E_INVALIDARG;
1125
1126     array = heap_alloc(sizeof(LPITEMIDLIST)*count);
1127
1128     i = 0;
1129     LIST_FOR_EACH_ENTRY(root, &This->roots, nstc_root, entry)
1130         SHGetIDListFromObject((IUnknown*)root->psi, &array[i++]);
1131
1132     SHGetDesktopFolder(&psf);
1133     hr = SHCreateShellItemArray(NULL, psf, count, (PCUITEMID_CHILD_ARRAY)array,
1134                                 ppsiaRootItems);
1135     IShellFolder_Release(psf);
1136
1137     for(i = 0; i < count; i++)
1138         ILFree(array[i]);
1139
1140     heap_free(array);
1141
1142     return hr;
1143 }
1144
1145 static HRESULT WINAPI NSTC2_fnSetItemState(INameSpaceTreeControl2* iface,
1146                                            IShellItem *psi,
1147                                            NSTCITEMSTATE nstcisMask,
1148                                            NSTCITEMSTATE nstcisFlags)
1149 {
1150     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
1151     TVITEMEXW tvi;
1152     HTREEITEM hitem;
1153
1154     TRACE("%p (%p, %x, %x)\n", This, psi, nstcisMask, nstcisFlags);
1155
1156     hitem = treeitem_from_shellitem(This, psi);
1157     if(!hitem) return E_INVALIDARG;
1158
1159     /* Passing both NSTCIS_SELECTED and NSTCIS_SELECTEDNOEXPAND results
1160        in two TVM_SETITEMW's */
1161     if((nstcisMask&nstcisFlags) & NSTCIS_SELECTED)
1162     {
1163         SendMessageW(This->hwnd_tv, TVM_SELECTITEM, TVGN_CARET, (LPARAM)hitem);
1164         SendMessageW(This->hwnd_tv, TVM_ENSUREVISIBLE, 0, (LPARAM)hitem);
1165     }
1166     if((nstcisMask&nstcisFlags) & NSTCIS_SELECTEDNOEXPAND)
1167     {
1168         SendMessageW(This->hwnd_tv, TVM_SELECTITEM, TVGN_CARET|TVSI_NOSINGLEEXPAND, (LPARAM)hitem);
1169     }
1170
1171     /* If NSTCIS_EXPANDED is among the flags, the mask is ignored. */
1172     if((nstcisMask|nstcisFlags) & NSTCIS_EXPANDED)
1173     {
1174         WPARAM arg = nstcisFlags&NSTCIS_EXPANDED ? TVE_EXPAND:TVE_COLLAPSE;
1175         SendMessageW(This->hwnd_tv, TVM_EXPAND, arg, (LPARAM)hitem);
1176     }
1177
1178     if(nstcisMask & NSTCIS_DISABLED)
1179         tvi.mask = TVIF_STATE | TVIF_STATEEX;
1180     else if( ((nstcisMask^nstcisFlags) & (NSTCIS_SELECTED|NSTCIS_EXPANDED|NSTCIS_SELECTEDNOEXPAND)) ||
1181              ((nstcisMask|nstcisFlags) & NSTCIS_BOLD) ||
1182              (nstcisFlags & NSTCIS_DISABLED) )
1183         tvi.mask = TVIF_STATE;
1184     else
1185         tvi.mask = 0;
1186
1187     if(tvi.mask)
1188     {
1189         tvi.stateMask = tvi.state = 0;
1190         tvi.stateMask |= ((nstcisFlags^nstcisMask)&NSTCIS_SELECTED) ? TVIS_SELECTED : 0;
1191         tvi.stateMask |= (nstcisMask|nstcisFlags)&NSTCIS_BOLD ? TVIS_BOLD:0;
1192         tvi.state     |= (nstcisMask&nstcisFlags)&NSTCIS_BOLD ? TVIS_BOLD:0;
1193
1194         if((nstcisMask&NSTCIS_EXPANDED)^(nstcisFlags&NSTCIS_EXPANDED))
1195         {
1196             tvi.stateMask = 0;
1197         }
1198
1199         tvi.uStateEx = (nstcisFlags&nstcisMask)&NSTCIS_DISABLED?TVIS_EX_DISABLED:0;
1200         tvi.hItem = hitem;
1201
1202         SendMessageW(This->hwnd_tv, TVM_SETITEMW, 0, (LPARAM)&tvi);
1203     }
1204
1205     return S_OK;
1206 }
1207
1208 static HRESULT WINAPI NSTC2_fnGetItemState(INameSpaceTreeControl2* iface,
1209                                            IShellItem *psi,
1210                                            NSTCITEMSTATE nstcisMask,
1211                                            NSTCITEMSTATE *pnstcisFlags)
1212 {
1213     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
1214     HTREEITEM hitem;
1215     TVITEMEXW tvi;
1216     TRACE("%p (%p, %x, %p)\n", This, psi, nstcisMask, pnstcisFlags);
1217
1218     hitem = treeitem_from_shellitem(This, psi);
1219     if(!hitem)
1220         return E_INVALIDARG;
1221
1222     *pnstcisFlags = 0;
1223
1224     tvi.hItem = hitem;
1225     tvi.mask = TVIF_STATE;
1226     tvi.stateMask = TVIS_SELECTED|TVIS_EXPANDED|TVIS_BOLD;
1227
1228     if(nstcisMask & NSTCIS_DISABLED)
1229         tvi.mask |= TVIF_STATEEX;
1230
1231     SendMessageW(This->hwnd_tv, TVM_GETITEMW, 0, (LPARAM)&tvi);
1232     *pnstcisFlags |= (tvi.state & TVIS_SELECTED)?NSTCIS_SELECTED:0;
1233     *pnstcisFlags |= (tvi.state & TVIS_EXPANDED)?NSTCIS_EXPANDED:0;
1234     *pnstcisFlags |= (tvi.state & TVIS_BOLD)?NSTCIS_BOLD:0;
1235     *pnstcisFlags |= (tvi.uStateEx & TVIS_EX_DISABLED)?NSTCIS_DISABLED:0;
1236
1237     *pnstcisFlags &= nstcisMask;
1238
1239     return S_OK;
1240 }
1241
1242 static HRESULT WINAPI NSTC2_fnGetSelectedItems(INameSpaceTreeControl2* iface,
1243                                                IShellItemArray **psiaItems)
1244 {
1245     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
1246     IShellItem *psiselected;
1247
1248     TRACE("%p (%p)\n", This, psiaItems);
1249
1250     psiselected = get_selected_shellitem(This);
1251     if(!psiselected)
1252     {
1253         *psiaItems = NULL;
1254         return E_FAIL;
1255     }
1256
1257     return SHCreateShellItemArrayFromShellItem(psiselected, &IID_IShellItemArray,
1258                                              (void**)psiaItems);
1259 }
1260
1261 static HRESULT WINAPI NSTC2_fnGetItemCustomState(INameSpaceTreeControl2* iface,
1262                                                  IShellItem *psi,
1263                                                  int *piStateNumber)
1264 {
1265     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
1266     FIXME("stub, %p (%p, %p)\n", This, psi, piStateNumber);
1267     return E_NOTIMPL;
1268 }
1269
1270 static HRESULT WINAPI NSTC2_fnSetItemCustomState(INameSpaceTreeControl2* iface,
1271                                                  IShellItem *psi,
1272                                                  int iStateNumber)
1273 {
1274     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
1275     FIXME("stub, %p (%p, %d)\n", This, psi, iStateNumber);
1276     return E_NOTIMPL;
1277 }
1278
1279 static HRESULT WINAPI NSTC2_fnEnsureItemVisible(INameSpaceTreeControl2* iface,
1280                                                 IShellItem *psi)
1281 {
1282     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
1283     HTREEITEM hitem;
1284
1285     TRACE("%p (%p)\n", This, psi);
1286
1287     hitem = treeitem_from_shellitem(This, psi);
1288     if(hitem)
1289     {
1290         SendMessageW(This->hwnd_tv, TVM_ENSUREVISIBLE, 0, (WPARAM)hitem);
1291         return S_OK;
1292     }
1293
1294     return E_INVALIDARG;
1295 }
1296
1297 static HRESULT WINAPI NSTC2_fnSetTheme(INameSpaceTreeControl2* iface,
1298                                        LPCWSTR pszTheme)
1299 {
1300     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
1301     FIXME("stub, %p (%p)\n", This, pszTheme);
1302     return E_NOTIMPL;
1303 }
1304
1305 static HRESULT WINAPI NSTC2_fnGetNextItem(INameSpaceTreeControl2* iface,
1306                                           IShellItem *psi,
1307                                           NSTCGNI nstcgi,
1308                                           IShellItem **ppsiNext)
1309 {
1310     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
1311     HTREEITEM hitem, hnext;
1312     UINT tvgn;
1313     TRACE("%p (%p, %x, %p)\n", This, psi, nstcgi, ppsiNext);
1314
1315     if(!ppsiNext) return E_POINTER;
1316     if(!psi)      return E_FAIL;
1317
1318     *ppsiNext = NULL;
1319
1320     hitem = treeitem_from_shellitem(This, psi);
1321     if(!hitem)
1322         return E_INVALIDARG;
1323
1324     switch(nstcgi)
1325     {
1326     case NSTCGNI_NEXT:         tvgn = TVGN_NEXT; break;
1327     case NSTCGNI_NEXTVISIBLE:  tvgn = TVGN_NEXTVISIBLE; break;
1328     case NSTCGNI_PREV:         tvgn = TVGN_PREVIOUS; break;
1329     case NSTCGNI_PREVVISIBLE:  tvgn = TVGN_PREVIOUSVISIBLE; break;
1330     case NSTCGNI_PARENT:       tvgn = TVGN_PARENT; break;
1331     case NSTCGNI_CHILD:        tvgn = TVGN_CHILD; break;
1332     case NSTCGNI_FIRSTVISIBLE: tvgn = TVGN_FIRSTVISIBLE; break;
1333     case NSTCGNI_LASTVISIBLE:  tvgn = TVGN_LASTVISIBLE; break;
1334     default:
1335         FIXME("Unknown nstcgi value %d\n", nstcgi);
1336         return E_FAIL;
1337     }
1338
1339     hnext = (HTREEITEM)SendMessageW(This->hwnd_tv, TVM_GETNEXTITEM, tvgn, (WPARAM)hitem);
1340     if(hnext)
1341     {
1342         *ppsiNext = shellitem_from_treeitem(This, hnext);
1343         IShellItem_AddRef(*ppsiNext);
1344         return S_OK;
1345     }
1346
1347     return E_FAIL;
1348 }
1349
1350 static HRESULT WINAPI NSTC2_fnHitTest(INameSpaceTreeControl2* iface,
1351                                       POINT *ppt,
1352                                       IShellItem **ppsiOut)
1353 {
1354     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
1355     HTREEITEM hitem;
1356     TRACE("%p (%p, %p)\n", This, ppsiOut, ppt);
1357
1358     if(!ppt || !ppsiOut)
1359         return E_POINTER;
1360
1361     *ppsiOut = NULL;
1362
1363     hitem = treeitem_from_point(This, ppt, NULL);
1364     if(hitem)
1365         *ppsiOut = shellitem_from_treeitem(This, hitem);
1366
1367     if(*ppsiOut)
1368     {
1369         IShellItem_AddRef(*ppsiOut);
1370         return S_OK;
1371     }
1372
1373     return S_FALSE;
1374 }
1375
1376 static HRESULT WINAPI NSTC2_fnGetItemRect(INameSpaceTreeControl2* iface,
1377                                           IShellItem *psi,
1378                                           RECT *prect)
1379 {
1380     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
1381     HTREEITEM hitem;
1382     TRACE("%p (%p, %p)\n", This, psi, prect);
1383
1384     if(!psi || !prect)
1385         return E_POINTER;
1386
1387     hitem = treeitem_from_shellitem(This, psi);
1388     if(hitem)
1389     {
1390         *(HTREEITEM*)prect = hitem;
1391         if(SendMessageW(This->hwnd_tv, TVM_GETITEMRECT, FALSE, (LPARAM)prect))
1392         {
1393             MapWindowPoints(This->hwnd_tv, HWND_DESKTOP, (POINT*)prect, 2);
1394             return S_OK;
1395         }
1396     }
1397
1398     return E_INVALIDARG;
1399 }
1400
1401 static HRESULT WINAPI NSTC2_fnCollapseAll(INameSpaceTreeControl2* iface)
1402 {
1403     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
1404     nstc_root *root;
1405     TRACE("%p\n", This);
1406
1407     LIST_FOR_EACH_ENTRY(root, &This->roots, nstc_root, entry)
1408         collapse_all(This, root->htreeitem);
1409
1410     return S_OK;
1411 }
1412
1413 static HRESULT WINAPI NSTC2_fnSetControlStyle(INameSpaceTreeControl2* iface,
1414                                               NSTCSTYLE nstcsMask,
1415                                               NSTCSTYLE nstcsStyle)
1416 {
1417     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
1418     static const DWORD tv_style_flags =
1419         NSTCS_HASEXPANDOS | NSTCS_HASLINES | NSTCS_FULLROWSELECT |
1420         NSTCS_HORIZONTALSCROLL | NSTCS_ROOTHASEXPANDO |
1421         NSTCS_SHOWSELECTIONALWAYS | NSTCS_NOINFOTIP | NSTCS_EVENHEIGHT |
1422         NSTCS_DISABLEDRAGDROP | NSTCS_NOEDITLABELS | NSTCS_CHECKBOXES;
1423     static const DWORD host_style_flags = NSTCS_TABSTOP | NSTCS_BORDER;
1424     static const DWORD nstc_flags =
1425         NSTCS_SINGLECLICKEXPAND | NSTCS_NOREPLACEOPEN | NSTCS_NOORDERSTREAM |
1426         NSTCS_FAVORITESMODE | NSTCS_EMPTYTEXT | NSTCS_ALLOWJUNCTIONS |
1427         NSTCS_SHOWTABSBUTTON | NSTCS_SHOWDELETEBUTTON | NSTCS_SHOWREFRESHBUTTON;
1428     TRACE("%p (%x, %x)\n", This, nstcsMask, nstcsStyle);
1429
1430     /* Fail if there is an attempt to set an unknown style. */
1431     if(nstcsMask & ~(tv_style_flags | host_style_flags | nstc_flags))
1432         return E_FAIL;
1433
1434     if(nstcsMask & tv_style_flags)
1435     {
1436         DWORD new_style;
1437         treeview_style_from_nstcs(This, nstcsStyle, nstcsMask, &new_style);
1438         SetWindowLongPtrW(This->hwnd_tv, GWL_STYLE, new_style);
1439     }
1440
1441     /* Flags affecting the host window */
1442     if(nstcsMask & NSTCS_BORDER)
1443     {
1444         DWORD new_style = GetWindowLongPtrW(This->hwnd_main, GWL_STYLE);
1445         new_style &= ~WS_BORDER;
1446         new_style |= nstcsStyle & NSTCS_BORDER ? WS_BORDER : 0;
1447         SetWindowLongPtrW(This->hwnd_main, GWL_STYLE, new_style);
1448     }
1449     if(nstcsMask & NSTCS_TABSTOP)
1450     {
1451         DWORD new_style = GetWindowLongPtrW(This->hwnd_main, GWL_EXSTYLE);
1452         new_style &= ~WS_EX_CONTROLPARENT;
1453         new_style |= nstcsStyle & NSTCS_TABSTOP ? WS_EX_CONTROLPARENT : 0;
1454         SetWindowLongPtrW(This->hwnd_main, GWL_EXSTYLE, new_style);
1455     }
1456
1457     if((nstcsStyle & nstcsMask) & unsupported_styles)
1458         FIXME("mask & style (0x%08x) contains unsupported style(s): 0x%08x\n",
1459               (nstcsStyle & nstcsMask),
1460               (nstcsStyle & nstcsMask) & unsupported_styles);
1461
1462     This->style &= ~nstcsMask;
1463     This->style |= (nstcsStyle & nstcsMask);
1464
1465     return S_OK;
1466 }
1467
1468 static HRESULT WINAPI NSTC2_fnGetControlStyle(INameSpaceTreeControl2* iface,
1469                                               NSTCSTYLE nstcsMask,
1470                                               NSTCSTYLE *pnstcsStyle)
1471 {
1472     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
1473     TRACE("%p (%x, %p)\n", This, nstcsMask, pnstcsStyle);
1474
1475     *pnstcsStyle = (This->style & nstcsMask);
1476
1477     return S_OK;
1478 }
1479
1480 static HRESULT WINAPI NSTC2_fnSetControlStyle2(INameSpaceTreeControl2* iface,
1481                                                NSTCSTYLE2 nstcsMask,
1482                                                NSTCSTYLE2 nstcsStyle)
1483 {
1484     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
1485     TRACE("%p (%x, %x)\n", This, nstcsMask, nstcsStyle);
1486
1487     if((nstcsStyle & nstcsMask) & unsupported_styles2)
1488         FIXME("mask & style (0x%08x) contains unsupported style(s): 0x%08x\n",
1489               (nstcsStyle & nstcsMask),
1490               (nstcsStyle & nstcsMask) & unsupported_styles2);
1491
1492     This->style2 &= ~nstcsMask;
1493     This->style2 |= (nstcsStyle & nstcsMask);
1494
1495     return S_OK;
1496 }
1497
1498 static HRESULT WINAPI NSTC2_fnGetControlStyle2(INameSpaceTreeControl2* iface,
1499                                                NSTCSTYLE2 nstcsMask,
1500                                                NSTCSTYLE2 *pnstcsStyle)
1501 {
1502     NSTC2Impl *This = impl_from_INameSpaceTreeControl2(iface);
1503     TRACE("%p (%x, %p)\n", This, nstcsMask, pnstcsStyle);
1504
1505     *pnstcsStyle = (This->style2 & nstcsMask);
1506
1507     return S_OK;
1508 }
1509
1510 static const INameSpaceTreeControl2Vtbl vt_INameSpaceTreeControl2 = {
1511     NSTC2_fnQueryInterface,
1512     NSTC2_fnAddRef,
1513     NSTC2_fnRelease,
1514     NSTC2_fnInitialize,
1515     NSTC2_fnTreeAdvise,
1516     NSTC2_fnTreeUnadvise,
1517     NSTC2_fnAppendRoot,
1518     NSTC2_fnInsertRoot,
1519     NSTC2_fnRemoveRoot,
1520     NSTC2_fnRemoveAllRoots,
1521     NSTC2_fnGetRootItems,
1522     NSTC2_fnSetItemState,
1523     NSTC2_fnGetItemState,
1524     NSTC2_fnGetSelectedItems,
1525     NSTC2_fnGetItemCustomState,
1526     NSTC2_fnSetItemCustomState,
1527     NSTC2_fnEnsureItemVisible,
1528     NSTC2_fnSetTheme,
1529     NSTC2_fnGetNextItem,
1530     NSTC2_fnHitTest,
1531     NSTC2_fnGetItemRect,
1532     NSTC2_fnCollapseAll,
1533     NSTC2_fnSetControlStyle,
1534     NSTC2_fnGetControlStyle,
1535     NSTC2_fnSetControlStyle2,
1536     NSTC2_fnGetControlStyle2
1537 };
1538
1539 /**************************************************************************
1540  * IOleWindow Implementation
1541  */
1542
1543 static HRESULT WINAPI IOW_fnQueryInterface(IOleWindow *iface, REFIID riid, void **ppvObject)
1544 {
1545     NSTC2Impl *This = impl_from_IOleWindow(iface);
1546     return INameSpaceTreeControl2_QueryInterface(&This->INameSpaceTreeControl2_iface, riid, ppvObject);
1547 }
1548
1549 static ULONG WINAPI IOW_fnAddRef(IOleWindow *iface)
1550 {
1551     NSTC2Impl *This = impl_from_IOleWindow(iface);
1552     return INameSpaceTreeControl2_AddRef(&This->INameSpaceTreeControl2_iface);
1553 }
1554
1555 static ULONG WINAPI IOW_fnRelease(IOleWindow *iface)
1556 {
1557     NSTC2Impl *This = impl_from_IOleWindow(iface);
1558     return INameSpaceTreeControl2_Release(&This->INameSpaceTreeControl2_iface);
1559 }
1560
1561 static HRESULT WINAPI IOW_fnGetWindow(IOleWindow *iface, HWND *phwnd)
1562 {
1563     NSTC2Impl *This = impl_from_IOleWindow(iface);
1564     TRACE("%p (%p)\n", This, phwnd);
1565
1566     *phwnd = This->hwnd_main;
1567     return S_OK;
1568 }
1569
1570 static HRESULT WINAPI IOW_fnContextSensitiveHelp(IOleWindow *iface, BOOL fEnterMode)
1571 {
1572     NSTC2Impl *This = impl_from_IOleWindow(iface);
1573     TRACE("%p (%d)\n", This, fEnterMode);
1574
1575     /* Not implemented */
1576     return E_NOTIMPL;
1577 }
1578
1579 static const IOleWindowVtbl vt_IOleWindow = {
1580     IOW_fnQueryInterface,
1581     IOW_fnAddRef,
1582     IOW_fnRelease,
1583     IOW_fnGetWindow,
1584     IOW_fnContextSensitiveHelp
1585 };
1586
1587 HRESULT NamespaceTreeControl_Constructor(IUnknown *pUnkOuter, REFIID riid, void **ppv)
1588 {
1589     NSTC2Impl *nstc;
1590     HRESULT ret;
1591
1592     TRACE ("%p %s %p\n", pUnkOuter, debugstr_guid(riid), ppv);
1593
1594     if(!ppv)
1595         return E_POINTER;
1596     if(pUnkOuter)
1597         return CLASS_E_NOAGGREGATION;
1598
1599     EFRAME_LockModule();
1600
1601     nstc = heap_alloc_zero(sizeof(*nstc));
1602     if (!nstc)
1603         return E_OUTOFMEMORY;
1604
1605     nstc->ref = 1;
1606     nstc->INameSpaceTreeControl2_iface.lpVtbl = &vt_INameSpaceTreeControl2;
1607     nstc->IOleWindow_iface.lpVtbl = &vt_IOleWindow;
1608
1609     list_init(&nstc->roots);
1610
1611     ret = INameSpaceTreeControl2_QueryInterface(&nstc->INameSpaceTreeControl2_iface, riid, ppv);
1612     INameSpaceTreeControl2_Release(&nstc->INameSpaceTreeControl2_iface);
1613
1614     TRACE("--(%p)\n", ppv);
1615     return ret;
1616 }