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