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