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