]> git.saurik.com Git - wxWidgets.git/blob - src/msw/treectrl.cpp
Compilation fixes for PCH-less build after ownerdraw-refactor branch merge.
[wxWidgets.git] / src / msw / treectrl.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/treectrl.cpp
3 // Purpose: wxTreeCtrl
4 // Author: Julian Smart
5 // Modified by: Vadim Zeitlin to be less MSW-specific on 10.10.98
6 // Created: 1997
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 #if wxUSE_TREECTRL
28
29 #include "wx/treectrl.h"
30
31 #ifndef WX_PRECOMP
32 #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"
33 #include "wx/msw/missing.h"
34 #include "wx/dynarray.h"
35 #include "wx/log.h"
36 #include "wx/app.h"
37 #include "wx/settings.h"
38 #endif
39
40 #include "wx/dynlib.h"
41 #include "wx/msw/private.h"
42
43 // Set this to 1 to be _absolutely_ sure that repainting will work for all
44 // comctl32.dll versions
45 #define wxUSE_COMCTL32_SAFELY 0
46
47 #include "wx/imaglist.h"
48 #include "wx/msw/dragimag.h"
49
50 // macros to hide the cast ugliness
51 // --------------------------------
52
53 // get HTREEITEM from wxTreeItemId
54 #define HITEM(item) ((HTREEITEM)(((item).m_pItem)))
55
56
57 // older SDKs are missing these
58 #ifndef TVN_ITEMCHANGINGA
59
60 #define TVN_ITEMCHANGINGA (TVN_FIRST-16)
61 #define TVN_ITEMCHANGINGW (TVN_FIRST-17)
62
63 typedef struct tagNMTVITEMCHANGE
64 {
65 NMHDR hdr;
66 UINT uChanged;
67 HTREEITEM hItem;
68 UINT uStateNew;
69 UINT uStateOld;
70 LPARAM lParam;
71 } NMTVITEMCHANGE;
72
73 #endif
74
75
76 // this helper class is used on vista systems for preventing unwanted
77 // item state changes in the vista tree control. It is only effective in
78 // multi-select mode on vista systems.
79
80 // The vista tree control includes some new code that originally broke the
81 // multi-selection tree, causing seemingly spurious item selection state changes
82 // during Shift or Ctrl-click item selection. (To witness the original broken
83 // behavior, simply make IsLocked() below always return false). This problem was
84 // solved by using the following class to 'unlock' an item's selection state.
85
86 class TreeItemUnlocker
87 {
88 public:
89 // unlock a single item
90 TreeItemUnlocker(HTREEITEM item) { ms_unlockedItem = item; }
91
92 // unlock all items, don't use unless absolutely necessary
93 TreeItemUnlocker() { ms_unlockedItem = (HTREEITEM)-1; }
94
95 // lock everything back
96 ~TreeItemUnlocker() { ms_unlockedItem = NULL; }
97
98
99 // check if the item state is currently locked
100 static bool IsLocked(HTREEITEM item)
101 { return ms_unlockedItem != (HTREEITEM)-1 && item != ms_unlockedItem; }
102
103 private:
104 static HTREEITEM ms_unlockedItem;
105 };
106
107 HTREEITEM TreeItemUnlocker::ms_unlockedItem = NULL;
108
109 // another helper class: set the variable to true during its lifetime and reset
110 // it to false when it is destroyed
111 //
112 // it is currently always used with wxTreeCtrl::m_changingSelection
113 class TempSetter
114 {
115 public:
116 TempSetter(bool& var) : m_var(var)
117 {
118 wxASSERT_MSG( !m_var, "variable shouldn't be already set" );
119 m_var = true;
120 }
121
122 ~TempSetter()
123 {
124 m_var = false;
125 }
126
127 private:
128 bool& m_var;
129
130 wxDECLARE_NO_COPY_CLASS(TempSetter);
131 };
132
133 // ----------------------------------------------------------------------------
134 // private functions
135 // ----------------------------------------------------------------------------
136
137 // wrappers for TreeView_GetItem/TreeView_SetItem
138 static bool IsItemSelected(HWND hwndTV, HTREEITEM hItem)
139 {
140 TV_ITEM tvi;
141 tvi.mask = TVIF_STATE | TVIF_HANDLE;
142 tvi.stateMask = TVIS_SELECTED;
143 tvi.hItem = hItem;
144
145 TreeItemUnlocker unlocker(hItem);
146
147 if ( !TreeView_GetItem(hwndTV, &tvi) )
148 {
149 wxLogLastError(wxT("TreeView_GetItem"));
150 }
151
152 return (tvi.state & TVIS_SELECTED) != 0;
153 }
154
155 static bool SelectItem(HWND hwndTV, HTREEITEM hItem, bool select = true)
156 {
157 TV_ITEM tvi;
158 tvi.mask = TVIF_STATE | TVIF_HANDLE;
159 tvi.stateMask = TVIS_SELECTED;
160 tvi.state = select ? TVIS_SELECTED : 0;
161 tvi.hItem = hItem;
162
163 TreeItemUnlocker unlocker(hItem);
164
165 if ( TreeView_SetItem(hwndTV, &tvi) == -1 )
166 {
167 wxLogLastError(wxT("TreeView_SetItem"));
168 return false;
169 }
170
171 return true;
172 }
173
174 static inline void UnselectItem(HWND hwndTV, HTREEITEM htItem)
175 {
176 SelectItem(hwndTV, htItem, false);
177 }
178
179 static inline void ToggleItemSelection(HWND hwndTV, HTREEITEM htItem)
180 {
181 SelectItem(hwndTV, htItem, !IsItemSelected(hwndTV, htItem));
182 }
183
184 // helper function which selects all items in a range and, optionally,
185 // deselects all the other ones
186 //
187 // returns true if the selection changed at all or false if nothing changed
188
189 // flags for SelectRange()
190 enum
191 {
192 SR_SIMULATE = 1, // don't do anything, just return true or false
193 SR_UNSELECT_OTHERS = 2 // deselect the items not in range
194 };
195
196 static bool SelectRange(HWND hwndTV,
197 HTREEITEM htFirst,
198 HTREEITEM htLast,
199 int flags)
200 {
201 // find the first (or last) item and select it
202 bool changed = false;
203 bool cont = true;
204 HTREEITEM htItem = (HTREEITEM)TreeView_GetRoot(hwndTV);
205
206 while ( htItem && cont )
207 {
208 if ( (htItem == htFirst) || (htItem == htLast) )
209 {
210 if ( !IsItemSelected(hwndTV, htItem) )
211 {
212 if ( !(flags & SR_SIMULATE) )
213 {
214 SelectItem(hwndTV, htItem);
215 }
216
217 changed = true;
218 }
219
220 cont = false;
221 }
222 else // not first or last
223 {
224 if ( flags & SR_UNSELECT_OTHERS )
225 {
226 if ( IsItemSelected(hwndTV, htItem) )
227 {
228 if ( !(flags & SR_SIMULATE) )
229 UnselectItem(hwndTV, htItem);
230
231 changed = true;
232 }
233 }
234 }
235
236 htItem = (HTREEITEM)TreeView_GetNextVisible(hwndTV, htItem);
237 }
238
239 // select the items in range
240 cont = htFirst != htLast;
241 while ( htItem && cont )
242 {
243 if ( !IsItemSelected(hwndTV, htItem) )
244 {
245 if ( !(flags & SR_SIMULATE) )
246 {
247 SelectItem(hwndTV, htItem);
248 }
249
250 changed = true;
251 }
252
253 cont = (htItem != htFirst) && (htItem != htLast);
254
255 htItem = (HTREEITEM)TreeView_GetNextVisible(hwndTV, htItem);
256 }
257
258 // optionally deselect the rest
259 if ( flags & SR_UNSELECT_OTHERS )
260 {
261 while ( htItem )
262 {
263 if ( IsItemSelected(hwndTV, htItem) )
264 {
265 if ( !(flags & SR_SIMULATE) )
266 {
267 UnselectItem(hwndTV, htItem);
268 }
269
270 changed = true;
271 }
272
273 htItem = (HTREEITEM)TreeView_GetNextVisible(hwndTV, htItem);
274 }
275 }
276
277 // seems to be necessary - otherwise the just selected items don't always
278 // appear as selected
279 if ( !(flags & SR_SIMULATE) )
280 {
281 UpdateWindow(hwndTV);
282 }
283
284 return changed;
285 }
286
287 // helper function which tricks the standard control into changing the focused
288 // item without changing anything else (if someone knows why Microsoft doesn't
289 // allow to do it by just setting TVIS_FOCUSED flag, please tell me!)
290 //
291 // returns true if the focus was changed, false if the given item was already
292 // the focused one
293 static bool SetFocus(HWND hwndTV, HTREEITEM htItem)
294 {
295 // the current focus
296 HTREEITEM htFocus = (HTREEITEM)TreeView_GetSelection(hwndTV);
297
298 if ( htItem == htFocus )
299 return false;
300
301 if ( htItem )
302 {
303 // remember the selection state of the item
304 bool wasSelected = IsItemSelected(hwndTV, htItem);
305
306 if ( htFocus && IsItemSelected(hwndTV, htFocus) )
307 {
308 // prevent the tree from unselecting the old focus which it
309 // would do by default (TreeView_SelectItem unselects the
310 // focused item)
311 TreeView_SelectItem(hwndTV, 0);
312 SelectItem(hwndTV, htFocus);
313 }
314
315 TreeView_SelectItem(hwndTV, htItem);
316
317 if ( !wasSelected )
318 {
319 // need to clear the selection which TreeView_SelectItem() gave
320 // us
321 UnselectItem(hwndTV, htItem);
322 }
323 //else: was selected, still selected - ok
324 }
325 else // reset focus
326 {
327 bool wasFocusSelected = IsItemSelected(hwndTV, htFocus);
328
329 // just clear the focus
330 TreeView_SelectItem(hwndTV, 0);
331
332 if ( wasFocusSelected )
333 {
334 // restore the selection state
335 SelectItem(hwndTV, htFocus);
336 }
337 }
338
339 return true;
340 }
341
342 // ----------------------------------------------------------------------------
343 // private classes
344 // ----------------------------------------------------------------------------
345
346 // a convenient wrapper around TV_ITEM struct which adds a ctor
347 #ifdef __VISUALC__
348 #pragma warning( disable : 4097 ) // inheriting from typedef
349 #endif
350
351 struct wxTreeViewItem : public TV_ITEM
352 {
353 wxTreeViewItem(const wxTreeItemId& item, // the item handle
354 UINT mask_, // fields which are valid
355 UINT stateMask_ = 0) // for TVIF_STATE only
356 {
357 wxZeroMemory(*this);
358
359 // hItem member is always valid
360 mask = mask_ | TVIF_HANDLE;
361 stateMask = stateMask_;
362 hItem = HITEM(item);
363 }
364 };
365
366 // ----------------------------------------------------------------------------
367 // This class is our userdata/lParam for the TV_ITEMs stored in the treeview.
368 //
369 // We need this for a couple of reasons:
370 //
371 // 1) This class is needed for support of different images: the Win32 common
372 // control natively supports only 2 images (the normal one and another for the
373 // selected state). We wish to provide support for 2 more of them for folder
374 // items (i.e. those which have children): for expanded state and for expanded
375 // selected state. For this we use this structure to store the additional items
376 // images.
377 //
378 // 2) This class is also needed to hold the HITEM so that we can sort
379 // it correctly in the MSW sort callback.
380 //
381 // In addition it makes other workarounds such as this easier and helps
382 // simplify the code.
383 // ----------------------------------------------------------------------------
384
385 class wxTreeItemParam
386 {
387 public:
388 wxTreeItemParam()
389 {
390 m_data = NULL;
391
392 for ( size_t n = 0; n < WXSIZEOF(m_images); n++ )
393 {
394 m_images[n] = -1;
395 }
396 }
397
398 // dtor deletes the associated data as well
399 virtual ~wxTreeItemParam() { delete m_data; }
400
401 // accessors
402 // get the real data associated with the item
403 wxTreeItemData *GetData() const { return m_data; }
404 // change it
405 void SetData(wxTreeItemData *data) { m_data = data; }
406
407 // do we have such image?
408 bool HasImage(wxTreeItemIcon which) const { return m_images[which] != -1; }
409 // get image, falling back to the other images if this one is not
410 // specified
411 int GetImage(wxTreeItemIcon which) const
412 {
413 int image = m_images[which];
414 if ( image == -1 )
415 {
416 switch ( which )
417 {
418 case wxTreeItemIcon_SelectedExpanded:
419 image = GetImage(wxTreeItemIcon_Expanded);
420 if ( image != -1 )
421 break;
422 //else: fall through
423
424 case wxTreeItemIcon_Selected:
425 case wxTreeItemIcon_Expanded:
426 image = GetImage(wxTreeItemIcon_Normal);
427 break;
428
429 case wxTreeItemIcon_Normal:
430 // no fallback
431 break;
432
433 default:
434 wxFAIL_MSG( wxT("unsupported wxTreeItemIcon value") );
435 }
436 }
437
438 return image;
439 }
440 // change the given image
441 void SetImage(int image, wxTreeItemIcon which) { m_images[which] = image; }
442
443 // get item
444 const wxTreeItemId& GetItem() const { return m_item; }
445 // set item
446 void SetItem(const wxTreeItemId& item) { m_item = item; }
447
448 protected:
449 // all the images associated with the item
450 int m_images[wxTreeItemIcon_Max];
451
452 // item for sort callbacks
453 wxTreeItemId m_item;
454
455 // the real client data
456 wxTreeItemData *m_data;
457
458 wxDECLARE_NO_COPY_CLASS(wxTreeItemParam);
459 };
460
461 // wxVirutalNode is used in place of a single root when 'hidden' root is
462 // specified.
463 class wxVirtualNode : public wxTreeViewItem
464 {
465 public:
466 wxVirtualNode(wxTreeItemParam *param)
467 : wxTreeViewItem(TVI_ROOT, 0)
468 {
469 m_param = param;
470 }
471
472 ~wxVirtualNode()
473 {
474 delete m_param;
475 }
476
477 wxTreeItemParam *GetParam() const { return m_param; }
478 void SetParam(wxTreeItemParam *param) { delete m_param; m_param = param; }
479
480 private:
481 wxTreeItemParam *m_param;
482
483 wxDECLARE_NO_COPY_CLASS(wxVirtualNode);
484 };
485
486 #ifdef __VISUALC__
487 #pragma warning( default : 4097 )
488 #endif
489
490 // a macro to get the virtual root, returns NULL if none
491 #define GET_VIRTUAL_ROOT() ((wxVirtualNode *)m_pVirtualRoot)
492
493 // returns true if the item is the virtual root
494 #define IS_VIRTUAL_ROOT(item) (HITEM(item) == TVI_ROOT)
495
496 // a class which encapsulates the tree traversal logic: it vists all (unless
497 // OnVisit() returns false) items under the given one
498 class wxTreeTraversal
499 {
500 public:
501 wxTreeTraversal(const wxTreeCtrl *tree)
502 {
503 m_tree = tree;
504 }
505
506 // give it a virtual dtor: not really needed as the class is never used
507 // polymorphically and not even allocated on heap at all, but this is safer
508 // (in case it ever is) and silences the compiler warnings for now
509 virtual ~wxTreeTraversal() { }
510
511 // do traverse the tree: visit all items (recursively by default) under the
512 // given one; return true if all items were traversed or false if the
513 // traversal was aborted because OnVisit returned false
514 bool DoTraverse(const wxTreeItemId& root, bool recursively = true);
515
516 // override this function to do whatever is needed for each item, return
517 // false to stop traversing
518 virtual bool OnVisit(const wxTreeItemId& item) = 0;
519
520 protected:
521 const wxTreeCtrl *GetTree() const { return m_tree; }
522
523 private:
524 bool Traverse(const wxTreeItemId& root, bool recursively);
525
526 const wxTreeCtrl *m_tree;
527
528 wxDECLARE_NO_COPY_CLASS(wxTreeTraversal);
529 };
530
531 // internal class for getting the selected items
532 class TraverseSelections : public wxTreeTraversal
533 {
534 public:
535 TraverseSelections(const wxTreeCtrl *tree,
536 wxArrayTreeItemIds& selections)
537 : wxTreeTraversal(tree), m_selections(selections)
538 {
539 m_selections.Empty();
540
541 if (tree->GetCount() > 0)
542 DoTraverse(tree->GetRootItem());
543 }
544
545 virtual bool OnVisit(const wxTreeItemId& item)
546 {
547 const wxTreeCtrl * const tree = GetTree();
548
549 // can't visit a virtual node.
550 if ( (tree->GetRootItem() == item) && tree->HasFlag(wxTR_HIDE_ROOT) )
551 {
552 return true;
553 }
554
555 if ( ::IsItemSelected(GetHwndOf(tree), HITEM(item)) )
556 {
557 m_selections.Add(item);
558 }
559
560 return true;
561 }
562
563 size_t GetCount() const { return m_selections.GetCount(); }
564
565 private:
566 wxArrayTreeItemIds& m_selections;
567
568 wxDECLARE_NO_COPY_CLASS(TraverseSelections);
569 };
570
571 // internal class for counting tree items
572 class TraverseCounter : public wxTreeTraversal
573 {
574 public:
575 TraverseCounter(const wxTreeCtrl *tree,
576 const wxTreeItemId& root,
577 bool recursively)
578 : wxTreeTraversal(tree)
579 {
580 m_count = 0;
581
582 DoTraverse(root, recursively);
583 }
584
585 virtual bool OnVisit(const wxTreeItemId& WXUNUSED(item))
586 {
587 m_count++;
588
589 return true;
590 }
591
592 size_t GetCount() const { return m_count; }
593
594 private:
595 size_t m_count;
596
597 wxDECLARE_NO_COPY_CLASS(TraverseCounter);
598 };
599
600 // ----------------------------------------------------------------------------
601 // wxWin macros
602 // ----------------------------------------------------------------------------
603
604 #if wxUSE_EXTENDED_RTTI
605 WX_DEFINE_FLAGS( wxTreeCtrlStyle )
606
607 wxBEGIN_FLAGS( wxTreeCtrlStyle )
608 // new style border flags, we put them first to
609 // use them for streaming out
610 wxFLAGS_MEMBER(wxBORDER_SIMPLE)
611 wxFLAGS_MEMBER(wxBORDER_SUNKEN)
612 wxFLAGS_MEMBER(wxBORDER_DOUBLE)
613 wxFLAGS_MEMBER(wxBORDER_RAISED)
614 wxFLAGS_MEMBER(wxBORDER_STATIC)
615 wxFLAGS_MEMBER(wxBORDER_NONE)
616
617 // old style border flags
618 wxFLAGS_MEMBER(wxSIMPLE_BORDER)
619 wxFLAGS_MEMBER(wxSUNKEN_BORDER)
620 wxFLAGS_MEMBER(wxDOUBLE_BORDER)
621 wxFLAGS_MEMBER(wxRAISED_BORDER)
622 wxFLAGS_MEMBER(wxSTATIC_BORDER)
623 wxFLAGS_MEMBER(wxBORDER)
624
625 // standard window styles
626 wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
627 wxFLAGS_MEMBER(wxCLIP_CHILDREN)
628 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
629 wxFLAGS_MEMBER(wxWANTS_CHARS)
630 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
631 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
632 wxFLAGS_MEMBER(wxVSCROLL)
633 wxFLAGS_MEMBER(wxHSCROLL)
634
635 wxFLAGS_MEMBER(wxTR_EDIT_LABELS)
636 wxFLAGS_MEMBER(wxTR_NO_BUTTONS)
637 wxFLAGS_MEMBER(wxTR_HAS_BUTTONS)
638 wxFLAGS_MEMBER(wxTR_TWIST_BUTTONS)
639 wxFLAGS_MEMBER(wxTR_NO_LINES)
640 wxFLAGS_MEMBER(wxTR_FULL_ROW_HIGHLIGHT)
641 wxFLAGS_MEMBER(wxTR_LINES_AT_ROOT)
642 wxFLAGS_MEMBER(wxTR_HIDE_ROOT)
643 wxFLAGS_MEMBER(wxTR_ROW_LINES)
644 wxFLAGS_MEMBER(wxTR_HAS_VARIABLE_ROW_HEIGHT)
645 wxFLAGS_MEMBER(wxTR_SINGLE)
646 wxFLAGS_MEMBER(wxTR_MULTIPLE)
647 #if WXWIN_COMPATIBILITY_2_8
648 wxFLAGS_MEMBER(wxTR_EXTENDED)
649 #endif
650 wxFLAGS_MEMBER(wxTR_DEFAULT_STYLE)
651
652 wxEND_FLAGS( wxTreeCtrlStyle )
653
654 IMPLEMENT_DYNAMIC_CLASS_XTI(wxTreeCtrl, wxControl,"wx/treectrl.h")
655
656 wxBEGIN_PROPERTIES_TABLE(wxTreeCtrl)
657 wxEVENT_PROPERTY( TextUpdated , wxEVT_COMMAND_TEXT_UPDATED , wxCommandEvent )
658 wxEVENT_RANGE_PROPERTY( TreeEvent , wxEVT_COMMAND_TREE_BEGIN_DRAG , wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK , wxTreeEvent )
659 wxPROPERTY_FLAGS( WindowStyle , wxTreeCtrlStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
660 wxEND_PROPERTIES_TABLE()
661
662 wxBEGIN_HANDLERS_TABLE(wxTreeCtrl)
663 wxEND_HANDLERS_TABLE()
664
665 wxCONSTRUCTOR_5( wxTreeCtrl , wxWindow* , Parent , wxWindowID , Id , wxPoint , Position , wxSize , Size , long , WindowStyle )
666 #else
667 IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxControl)
668 #endif
669
670 // ----------------------------------------------------------------------------
671 // constants
672 // ----------------------------------------------------------------------------
673
674 // indices in gs_expandEvents table below
675 enum
676 {
677 IDX_COLLAPSE,
678 IDX_EXPAND,
679 IDX_WHAT_MAX
680 };
681
682 enum
683 {
684 IDX_DONE,
685 IDX_DOING,
686 IDX_HOW_MAX
687 };
688
689 // handy table for sending events - it has to be initialized during run-time
690 // now so can't be const any more
691 static /* const */ wxEventType gs_expandEvents[IDX_WHAT_MAX][IDX_HOW_MAX];
692
693 /*
694 but logically it's a const table with the following entries:
695 =
696 {
697 { wxEVT_COMMAND_TREE_ITEM_COLLAPSED, wxEVT_COMMAND_TREE_ITEM_COLLAPSING },
698 { wxEVT_COMMAND_TREE_ITEM_EXPANDED, wxEVT_COMMAND_TREE_ITEM_EXPANDING }
699 };
700 */
701
702 // ============================================================================
703 // implementation
704 // ============================================================================
705
706 // ----------------------------------------------------------------------------
707 // tree traversal
708 // ----------------------------------------------------------------------------
709
710 bool wxTreeTraversal::DoTraverse(const wxTreeItemId& root, bool recursively)
711 {
712 if ( !OnVisit(root) )
713 return false;
714
715 return Traverse(root, recursively);
716 }
717
718 bool wxTreeTraversal::Traverse(const wxTreeItemId& root, bool recursively)
719 {
720 wxTreeItemIdValue cookie;
721 wxTreeItemId child = m_tree->GetFirstChild(root, cookie);
722 while ( child.IsOk() )
723 {
724 // depth first traversal
725 if ( recursively && !Traverse(child, true) )
726 return false;
727
728 if ( !OnVisit(child) )
729 return false;
730
731 child = m_tree->GetNextChild(root, cookie);
732 }
733
734 return true;
735 }
736
737 // ----------------------------------------------------------------------------
738 // construction and destruction
739 // ----------------------------------------------------------------------------
740
741 void wxTreeCtrl::Init()
742 {
743 m_textCtrl = NULL;
744 m_hasAnyAttr = false;
745 #if wxUSE_DRAGIMAGE
746 m_dragImage = NULL;
747 #endif
748 m_pVirtualRoot = NULL;
749 m_dragStarted = false;
750 m_focusLost = true;
751 m_changingSelection = false;
752 m_triggerStateImageClick = false;
753 m_mouseUpDeselect = false;
754
755 // initialize the global array of events now as it can't be done statically
756 // with the wxEVT_XXX values being allocated during run-time only
757 gs_expandEvents[IDX_COLLAPSE][IDX_DONE] = wxEVT_COMMAND_TREE_ITEM_COLLAPSED;
758 gs_expandEvents[IDX_COLLAPSE][IDX_DOING] = wxEVT_COMMAND_TREE_ITEM_COLLAPSING;
759 gs_expandEvents[IDX_EXPAND][IDX_DONE] = wxEVT_COMMAND_TREE_ITEM_EXPANDED;
760 gs_expandEvents[IDX_EXPAND][IDX_DOING] = wxEVT_COMMAND_TREE_ITEM_EXPANDING;
761 }
762
763 bool wxTreeCtrl::Create(wxWindow *parent,
764 wxWindowID id,
765 const wxPoint& pos,
766 const wxSize& size,
767 long style,
768 const wxValidator& validator,
769 const wxString& name)
770 {
771 Init();
772
773 if ( (style & wxBORDER_MASK) == wxBORDER_DEFAULT )
774 style |= wxBORDER_SUNKEN;
775
776 if ( !CreateControl(parent, id, pos, size, style, validator, name) )
777 return false;
778
779 WXDWORD exStyle = 0;
780 DWORD wstyle = MSWGetStyle(m_windowStyle, & exStyle);
781 wstyle |= WS_TABSTOP | TVS_SHOWSELALWAYS;
782
783 if ( !(m_windowStyle & wxTR_NO_LINES) )
784 wstyle |= TVS_HASLINES;
785 if ( m_windowStyle & wxTR_HAS_BUTTONS )
786 wstyle |= TVS_HASBUTTONS;
787
788 if ( m_windowStyle & wxTR_EDIT_LABELS )
789 wstyle |= TVS_EDITLABELS;
790
791 if ( m_windowStyle & wxTR_LINES_AT_ROOT )
792 wstyle |= TVS_LINESATROOT;
793
794 if ( m_windowStyle & wxTR_FULL_ROW_HIGHLIGHT )
795 {
796 if ( wxApp::GetComCtl32Version() >= 471 )
797 wstyle |= TVS_FULLROWSELECT;
798 }
799
800 #if !defined(__WXWINCE__) && defined(TVS_INFOTIP)
801 // Need so that TVN_GETINFOTIP messages will be sent
802 wstyle |= TVS_INFOTIP;
803 #endif
804
805 // Create the tree control.
806 if ( !MSWCreateControl(WC_TREEVIEW, wstyle, pos, size) )
807 return false;
808
809 #if wxUSE_COMCTL32_SAFELY
810 wxWindow::SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
811 wxWindow::SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
812 #elif 1
813 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
814 SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
815 #else
816 // This works around a bug in the Windows tree control whereby for some versions
817 // of comctrl32, setting any colour actually draws the background in black.
818 // This will initialise the background to the system colour.
819 // THIS FIX NOW REVERTED since it caused problems on _other_ systems.
820 // Assume the user has an updated comctl32.dll.
821 ::SendMessage(GetHwnd(), TVM_SETBKCOLOR, 0,-1);
822 wxWindow::SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
823 SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
824 #endif
825
826 wxSetCCUnicodeFormat(GetHwnd());
827
828 return true;
829 }
830
831 wxTreeCtrl::~wxTreeCtrl()
832 {
833 // delete any attributes
834 if ( m_hasAnyAttr )
835 {
836 WX_CLEAR_HASH_MAP(wxMapTreeAttr, m_attrs);
837
838 // prevent TVN_DELETEITEM handler from deleting the attributes again!
839 m_hasAnyAttr = false;
840 }
841
842 DeleteTextCtrl();
843
844 // delete user data to prevent memory leaks
845 // also deletes hidden root node storage.
846 DeleteAllItems();
847 }
848
849 // ----------------------------------------------------------------------------
850 // accessors
851 // ----------------------------------------------------------------------------
852
853 /* static */ wxVisualAttributes
854 wxTreeCtrl::GetClassDefaultAttributes(wxWindowVariant variant)
855 {
856 wxVisualAttributes attrs = GetCompositeControlsDefaultAttributes(variant);
857
858 // common controls have their own default font
859 attrs.font = wxGetCCDefaultFont();
860
861 return attrs;
862 }
863
864
865 // simple wrappers which add error checking in debug mode
866
867 bool wxTreeCtrl::DoGetItem(wxTreeViewItem *tvItem) const
868 {
869 wxCHECK_MSG( tvItem->hItem != TVI_ROOT, false,
870 wxT("can't retrieve virtual root item") );
871
872 if ( !TreeView_GetItem(GetHwnd(), tvItem) )
873 {
874 wxLogLastError(wxT("TreeView_GetItem"));
875
876 return false;
877 }
878
879 return true;
880 }
881
882 void wxTreeCtrl::DoSetItem(wxTreeViewItem *tvItem)
883 {
884 TreeItemUnlocker unlocker(tvItem->hItem);
885
886 if ( TreeView_SetItem(GetHwnd(), tvItem) == -1 )
887 {
888 wxLogLastError(wxT("TreeView_SetItem"));
889 }
890 }
891
892 unsigned int wxTreeCtrl::GetCount() const
893 {
894 return (unsigned int)TreeView_GetCount(GetHwnd());
895 }
896
897 unsigned int wxTreeCtrl::GetIndent() const
898 {
899 return TreeView_GetIndent(GetHwnd());
900 }
901
902 void wxTreeCtrl::SetIndent(unsigned int indent)
903 {
904 TreeView_SetIndent(GetHwnd(), indent);
905 }
906
907 void wxTreeCtrl::SetAnyImageList(wxImageList *imageList, int which)
908 {
909 // no error return
910 (void) TreeView_SetImageList(GetHwnd(),
911 imageList ? imageList->GetHIMAGELIST() : 0,
912 which);
913 }
914
915 void wxTreeCtrl::SetImageList(wxImageList *imageList)
916 {
917 if (m_ownsImageListNormal)
918 delete m_imageListNormal;
919
920 SetAnyImageList(m_imageListNormal = imageList, TVSIL_NORMAL);
921 m_ownsImageListNormal = false;
922 }
923
924 void wxTreeCtrl::SetStateImageList(wxImageList *imageList)
925 {
926 if (m_ownsImageListState) delete m_imageListState;
927 SetAnyImageList(m_imageListState = imageList, TVSIL_STATE);
928 m_ownsImageListState = false;
929 }
930
931 size_t wxTreeCtrl::GetChildrenCount(const wxTreeItemId& item,
932 bool recursively) const
933 {
934 wxCHECK_MSG( item.IsOk(), 0u, wxT("invalid tree item") );
935
936 TraverseCounter counter(this, item, recursively);
937 return counter.GetCount() - 1;
938 }
939
940 // ----------------------------------------------------------------------------
941 // control colours
942 // ----------------------------------------------------------------------------
943
944 bool wxTreeCtrl::SetBackgroundColour(const wxColour &colour)
945 {
946 #if !wxUSE_COMCTL32_SAFELY
947 if ( !wxWindowBase::SetBackgroundColour(colour) )
948 return false;
949
950 ::SendMessage(GetHwnd(), TVM_SETBKCOLOR, 0, colour.GetPixel());
951 #endif
952
953 return true;
954 }
955
956 bool wxTreeCtrl::SetForegroundColour(const wxColour &colour)
957 {
958 #if !wxUSE_COMCTL32_SAFELY
959 if ( !wxWindowBase::SetForegroundColour(colour) )
960 return false;
961
962 ::SendMessage(GetHwnd(), TVM_SETTEXTCOLOR, 0, colour.GetPixel());
963 #endif
964
965 return true;
966 }
967
968 // ----------------------------------------------------------------------------
969 // Item access
970 // ----------------------------------------------------------------------------
971
972 bool wxTreeCtrl::IsHiddenRoot(const wxTreeItemId& item) const
973 {
974 return HITEM(item) == TVI_ROOT && HasFlag(wxTR_HIDE_ROOT);
975 }
976
977 wxString wxTreeCtrl::GetItemText(const wxTreeItemId& item) const
978 {
979 wxCHECK_MSG( item.IsOk(), wxEmptyString, wxT("invalid tree item") );
980
981 wxChar buf[512]; // the size is arbitrary...
982
983 wxTreeViewItem tvItem(item, TVIF_TEXT);
984 tvItem.pszText = buf;
985 tvItem.cchTextMax = WXSIZEOF(buf);
986 if ( !DoGetItem(&tvItem) )
987 {
988 // don't return some garbage which was on stack, but an empty string
989 buf[0] = wxT('\0');
990 }
991
992 return wxString(buf);
993 }
994
995 void wxTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text)
996 {
997 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
998
999 if ( IS_VIRTUAL_ROOT(item) )
1000 return;
1001
1002 wxTreeViewItem tvItem(item, TVIF_TEXT);
1003 tvItem.pszText = (wxChar *)text.wx_str(); // conversion is ok
1004 DoSetItem(&tvItem);
1005
1006 // when setting the text of the item being edited, the text control should
1007 // be updated to reflect the new text as well, otherwise calling
1008 // SetItemText() in the OnBeginLabelEdit() handler doesn't have any effect
1009 //
1010 // don't use GetEditControl() here because m_textCtrl is not set yet
1011 HWND hwndEdit = TreeView_GetEditControl(GetHwnd());
1012 if ( hwndEdit )
1013 {
1014 if ( item == m_idEdited )
1015 {
1016 ::SetWindowText(hwndEdit, text.wx_str());
1017 }
1018 }
1019 }
1020
1021 int wxTreeCtrl::GetItemImage(const wxTreeItemId& item,
1022 wxTreeItemIcon which) const
1023 {
1024 wxCHECK_MSG( item.IsOk(), -1, wxT("invalid tree item") );
1025
1026 if ( IsHiddenRoot(item) )
1027 {
1028 // no images for hidden root item
1029 return -1;
1030 }
1031
1032 wxTreeItemParam *param = GetItemParam(item);
1033
1034 return param && param->HasImage(which) ? param->GetImage(which) : -1;
1035 }
1036
1037 void wxTreeCtrl::SetItemImage(const wxTreeItemId& item, int image,
1038 wxTreeItemIcon which)
1039 {
1040 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1041 wxCHECK_RET( which >= 0 &&
1042 which < wxTreeItemIcon_Max,
1043 wxT("invalid image index"));
1044
1045
1046 if ( IsHiddenRoot(item) )
1047 {
1048 // no images for hidden root item
1049 return;
1050 }
1051
1052 wxTreeItemParam *data = GetItemParam(item);
1053 if ( !data )
1054 return;
1055
1056 data->SetImage(image, which);
1057
1058 RefreshItem(item);
1059 }
1060
1061 wxTreeItemParam *wxTreeCtrl::GetItemParam(const wxTreeItemId& item) const
1062 {
1063 wxCHECK_MSG( item.IsOk(), NULL, wxT("invalid tree item") );
1064
1065 wxTreeViewItem tvItem(item, TVIF_PARAM);
1066
1067 // hidden root may still have data.
1068 if ( IS_VIRTUAL_ROOT(item) )
1069 {
1070 return GET_VIRTUAL_ROOT()->GetParam();
1071 }
1072
1073 // visible node.
1074 if ( !DoGetItem(&tvItem) )
1075 {
1076 return NULL;
1077 }
1078
1079 return (wxTreeItemParam *)tvItem.lParam;
1080 }
1081
1082 bool wxTreeCtrl::HandleTreeEvent(wxTreeEvent& event) const
1083 {
1084 if ( event.m_item.IsOk() )
1085 {
1086 event.SetClientObject(GetItemData(event.m_item));
1087 }
1088
1089 return HandleWindowEvent(event);
1090 }
1091
1092 wxTreeItemData *wxTreeCtrl::GetItemData(const wxTreeItemId& item) const
1093 {
1094 wxTreeItemParam *data = GetItemParam(item);
1095
1096 return data ? data->GetData() : NULL;
1097 }
1098
1099 void wxTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data)
1100 {
1101 // first, associate this piece of data with this item
1102 if ( data )
1103 {
1104 data->SetId(item);
1105 }
1106
1107 wxTreeItemParam *param = GetItemParam(item);
1108
1109 wxCHECK_RET( param, wxT("failed to change tree items data") );
1110
1111 param->SetData(data);
1112 }
1113
1114 void wxTreeCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
1115 {
1116 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1117
1118 if ( IS_VIRTUAL_ROOT(item) )
1119 return;
1120
1121 wxTreeViewItem tvItem(item, TVIF_CHILDREN);
1122 tvItem.cChildren = (int)has;
1123 DoSetItem(&tvItem);
1124 }
1125
1126 void wxTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
1127 {
1128 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1129
1130 if ( IS_VIRTUAL_ROOT(item) )
1131 return;
1132
1133 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_BOLD);
1134 tvItem.state = bold ? TVIS_BOLD : 0;
1135 DoSetItem(&tvItem);
1136 }
1137
1138 void wxTreeCtrl::SetItemDropHighlight(const wxTreeItemId& item, bool highlight)
1139 {
1140 if ( IS_VIRTUAL_ROOT(item) )
1141 return;
1142
1143 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_DROPHILITED);
1144 tvItem.state = highlight ? TVIS_DROPHILITED : 0;
1145 DoSetItem(&tvItem);
1146 }
1147
1148 void wxTreeCtrl::RefreshItem(const wxTreeItemId& item)
1149 {
1150 if ( IS_VIRTUAL_ROOT(item) )
1151 return;
1152
1153 wxRect rect;
1154 if ( GetBoundingRect(item, rect) )
1155 {
1156 RefreshRect(rect);
1157 }
1158 }
1159
1160 wxColour wxTreeCtrl::GetItemTextColour(const wxTreeItemId& item) const
1161 {
1162 wxCHECK_MSG( item.IsOk(), wxNullColour, wxT("invalid tree item") );
1163
1164 wxMapTreeAttr::const_iterator it = m_attrs.find(item.m_pItem);
1165 return it == m_attrs.end() ? wxNullColour : it->second->GetTextColour();
1166 }
1167
1168 wxColour wxTreeCtrl::GetItemBackgroundColour(const wxTreeItemId& item) const
1169 {
1170 wxCHECK_MSG( item.IsOk(), wxNullColour, wxT("invalid tree item") );
1171
1172 wxMapTreeAttr::const_iterator it = m_attrs.find(item.m_pItem);
1173 return it == m_attrs.end() ? wxNullColour : it->second->GetBackgroundColour();
1174 }
1175
1176 wxFont wxTreeCtrl::GetItemFont(const wxTreeItemId& item) const
1177 {
1178 wxCHECK_MSG( item.IsOk(), wxNullFont, wxT("invalid tree item") );
1179
1180 wxMapTreeAttr::const_iterator it = m_attrs.find(item.m_pItem);
1181 return it == m_attrs.end() ? wxNullFont : it->second->GetFont();
1182 }
1183
1184 void wxTreeCtrl::SetItemTextColour(const wxTreeItemId& item,
1185 const wxColour& col)
1186 {
1187 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1188
1189 wxTreeItemAttr *attr;
1190 wxMapTreeAttr::iterator it = m_attrs.find(item.m_pItem);
1191 if ( it == m_attrs.end() )
1192 {
1193 m_hasAnyAttr = true;
1194
1195 m_attrs[item.m_pItem] =
1196 attr = new wxTreeItemAttr;
1197 }
1198 else
1199 {
1200 attr = it->second;
1201 }
1202
1203 attr->SetTextColour(col);
1204
1205 RefreshItem(item);
1206 }
1207
1208 void wxTreeCtrl::SetItemBackgroundColour(const wxTreeItemId& item,
1209 const wxColour& col)
1210 {
1211 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1212
1213 wxTreeItemAttr *attr;
1214 wxMapTreeAttr::iterator it = m_attrs.find(item.m_pItem);
1215 if ( it == m_attrs.end() )
1216 {
1217 m_hasAnyAttr = true;
1218
1219 m_attrs[item.m_pItem] =
1220 attr = new wxTreeItemAttr;
1221 }
1222 else // already in the hash
1223 {
1224 attr = it->second;
1225 }
1226
1227 attr->SetBackgroundColour(col);
1228
1229 RefreshItem(item);
1230 }
1231
1232 void wxTreeCtrl::SetItemFont(const wxTreeItemId& item, const wxFont& font)
1233 {
1234 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1235
1236 wxTreeItemAttr *attr;
1237 wxMapTreeAttr::iterator it = m_attrs.find(item.m_pItem);
1238 if ( it == m_attrs.end() )
1239 {
1240 m_hasAnyAttr = true;
1241
1242 m_attrs[item.m_pItem] =
1243 attr = new wxTreeItemAttr;
1244 }
1245 else // already in the hash
1246 {
1247 attr = it->second;
1248 }
1249
1250 attr->SetFont(font);
1251
1252 // Reset the item's text to ensure that the bounding rect will be adjusted
1253 // for the new font.
1254 SetItemText(item, GetItemText(item));
1255
1256 RefreshItem(item);
1257 }
1258
1259 // ----------------------------------------------------------------------------
1260 // Item status
1261 // ----------------------------------------------------------------------------
1262
1263 bool wxTreeCtrl::IsVisible(const wxTreeItemId& item) const
1264 {
1265 wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
1266
1267 if ( item == wxTreeItemId(TVI_ROOT) )
1268 {
1269 // virtual (hidden) root is never visible
1270 return false;
1271 }
1272
1273 // Bug in Gnu-Win32 headers, so don't use the macro TreeView_GetItemRect
1274 RECT rect;
1275
1276 // this ugliness comes directly from MSDN - it *is* the correct way to pass
1277 // the HTREEITEM with TVM_GETITEMRECT
1278 *(HTREEITEM *)&rect = HITEM(item);
1279
1280 // true means to get rect for just the text, not the whole line
1281 if ( !::SendMessage(GetHwnd(), TVM_GETITEMRECT, true, (LPARAM)&rect) )
1282 {
1283 // if TVM_GETITEMRECT returned false, then the item is definitely not
1284 // visible (because its parent is not expanded)
1285 return false;
1286 }
1287
1288 // however if it returned true, the item might still be outside the
1289 // currently visible part of the tree, test for it (notice that partly
1290 // visible means visible here)
1291 return rect.bottom > 0 && rect.top < GetClientSize().y;
1292 }
1293
1294 bool wxTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const
1295 {
1296 wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
1297
1298 if ( IS_VIRTUAL_ROOT(item) )
1299 {
1300 wxTreeItemIdValue cookie;
1301 return GetFirstChild(item, cookie).IsOk();
1302 }
1303
1304 wxTreeViewItem tvItem(item, TVIF_CHILDREN);
1305 DoGetItem(&tvItem);
1306
1307 return tvItem.cChildren != 0;
1308 }
1309
1310 bool wxTreeCtrl::IsExpanded(const wxTreeItemId& item) const
1311 {
1312 wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
1313
1314 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_EXPANDED);
1315 DoGetItem(&tvItem);
1316
1317 return (tvItem.state & TVIS_EXPANDED) != 0;
1318 }
1319
1320 bool wxTreeCtrl::IsSelected(const wxTreeItemId& item) const
1321 {
1322 wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
1323
1324 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_SELECTED);
1325 DoGetItem(&tvItem);
1326
1327 return (tvItem.state & TVIS_SELECTED) != 0;
1328 }
1329
1330 bool wxTreeCtrl::IsBold(const wxTreeItemId& item) const
1331 {
1332 wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
1333
1334 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_BOLD);
1335 DoGetItem(&tvItem);
1336
1337 return (tvItem.state & TVIS_BOLD) != 0;
1338 }
1339
1340 // ----------------------------------------------------------------------------
1341 // navigation
1342 // ----------------------------------------------------------------------------
1343
1344 wxTreeItemId wxTreeCtrl::GetRootItem() const
1345 {
1346 // Root may be real (visible) or virtual (hidden).
1347 if ( GET_VIRTUAL_ROOT() )
1348 return TVI_ROOT;
1349
1350 return wxTreeItemId(TreeView_GetRoot(GetHwnd()));
1351 }
1352
1353 wxTreeItemId wxTreeCtrl::GetSelection() const
1354 {
1355 wxCHECK_MSG( !HasFlag(wxTR_MULTIPLE), wxTreeItemId(),
1356 wxT("this only works with single selection controls") );
1357
1358 return GetFocusedItem();
1359 }
1360
1361 wxTreeItemId wxTreeCtrl::GetFocusedItem() const
1362 {
1363 return wxTreeItemId(TreeView_GetSelection(GetHwnd()));
1364 }
1365
1366 wxTreeItemId wxTreeCtrl::GetItemParent(const wxTreeItemId& item) const
1367 {
1368 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1369
1370 HTREEITEM hItem;
1371
1372 if ( IS_VIRTUAL_ROOT(item) )
1373 {
1374 // no parent for the virtual root
1375 hItem = 0;
1376 }
1377 else // normal item
1378 {
1379 hItem = TreeView_GetParent(GetHwnd(), HITEM(item));
1380 if ( !hItem && HasFlag(wxTR_HIDE_ROOT) )
1381 {
1382 // the top level items should have the virtual root as their parent
1383 hItem = TVI_ROOT;
1384 }
1385 }
1386
1387 return wxTreeItemId(hItem);
1388 }
1389
1390 wxTreeItemId wxTreeCtrl::GetFirstChild(const wxTreeItemId& item,
1391 wxTreeItemIdValue& cookie) const
1392 {
1393 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1394
1395 // remember the last child returned in 'cookie'
1396 cookie = TreeView_GetChild(GetHwnd(), HITEM(item));
1397
1398 return wxTreeItemId(cookie);
1399 }
1400
1401 wxTreeItemId wxTreeCtrl::GetNextChild(const wxTreeItemId& WXUNUSED(item),
1402 wxTreeItemIdValue& cookie) const
1403 {
1404 wxTreeItemId fromCookie(cookie);
1405
1406 HTREEITEM hitem = HITEM(fromCookie);
1407
1408 hitem = TreeView_GetNextSibling(GetHwnd(), hitem);
1409
1410 wxTreeItemId item(hitem);
1411
1412 cookie = item.m_pItem;
1413
1414 return item;
1415 }
1416
1417 wxTreeItemId wxTreeCtrl::GetLastChild(const wxTreeItemId& item) const
1418 {
1419 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1420
1421 // can this be done more efficiently?
1422 wxTreeItemIdValue cookie;
1423
1424 wxTreeItemId childLast,
1425 child = GetFirstChild(item, cookie);
1426 while ( child.IsOk() )
1427 {
1428 childLast = child;
1429 child = GetNextChild(item, cookie);
1430 }
1431
1432 return childLast;
1433 }
1434
1435 wxTreeItemId wxTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
1436 {
1437 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1438 return wxTreeItemId(TreeView_GetNextSibling(GetHwnd(), HITEM(item)));
1439 }
1440
1441 wxTreeItemId wxTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const
1442 {
1443 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1444 return wxTreeItemId(TreeView_GetPrevSibling(GetHwnd(), HITEM(item)));
1445 }
1446
1447 wxTreeItemId wxTreeCtrl::GetFirstVisibleItem() const
1448 {
1449 return wxTreeItemId(TreeView_GetFirstVisible(GetHwnd()));
1450 }
1451
1452 wxTreeItemId wxTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
1453 {
1454 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1455 wxASSERT_MSG( IsVisible(item), wxT("The item you call GetNextVisible() for must be visible itself!"));
1456
1457 wxTreeItemId next(TreeView_GetNextVisible(GetHwnd(), HITEM(item)));
1458 if ( next.IsOk() && !IsVisible(next) )
1459 {
1460 // Win32 considers that any non-collapsed item is visible while we want
1461 // to return only really visible items
1462 next.Unset();
1463 }
1464
1465 return next;
1466 }
1467
1468 wxTreeItemId wxTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
1469 {
1470 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1471 wxASSERT_MSG( IsVisible(item), wxT("The item you call GetPrevVisible() for must be visible itself!"));
1472
1473 wxTreeItemId prev(TreeView_GetPrevVisible(GetHwnd(), HITEM(item)));
1474 if ( prev.IsOk() && !IsVisible(prev) )
1475 {
1476 // just as above, Win32 function will happily return the previous item
1477 // in the tree for the first visible item too
1478 prev.Unset();
1479 }
1480
1481 return prev;
1482 }
1483
1484 // ----------------------------------------------------------------------------
1485 // multiple selections emulation
1486 // ----------------------------------------------------------------------------
1487
1488 size_t wxTreeCtrl::GetSelections(wxArrayTreeItemIds& selections) const
1489 {
1490 TraverseSelections selector(this, selections);
1491
1492 return selector.GetCount();
1493 }
1494
1495 // ----------------------------------------------------------------------------
1496 // Usual operations
1497 // ----------------------------------------------------------------------------
1498
1499 wxTreeItemId wxTreeCtrl::DoInsertAfter(const wxTreeItemId& parent,
1500 const wxTreeItemId& hInsertAfter,
1501 const wxString& text,
1502 int image, int selectedImage,
1503 wxTreeItemData *data)
1504 {
1505 wxCHECK_MSG( parent.IsOk() || !TreeView_GetRoot(GetHwnd()),
1506 wxTreeItemId(),
1507 wxT("can't have more than one root in the tree") );
1508
1509 TV_INSERTSTRUCT tvIns;
1510 tvIns.hParent = HITEM(parent);
1511 tvIns.hInsertAfter = HITEM(hInsertAfter);
1512
1513 // this is how we insert the item as the first child: supply a NULL
1514 // hInsertAfter
1515 if ( !tvIns.hInsertAfter )
1516 {
1517 tvIns.hInsertAfter = TVI_FIRST;
1518 }
1519
1520 UINT mask = 0;
1521 if ( !text.empty() )
1522 {
1523 mask |= TVIF_TEXT;
1524 tvIns.item.pszText = (wxChar *)text.wx_str(); // cast is ok
1525 }
1526 else
1527 {
1528 tvIns.item.pszText = NULL;
1529 tvIns.item.cchTextMax = 0;
1530 }
1531
1532 // create the param which will store the other item parameters
1533 wxTreeItemParam *param = new wxTreeItemParam;
1534
1535 // we return the images on demand as they depend on whether the item is
1536 // expanded or collapsed too in our case
1537 mask |= TVIF_IMAGE | TVIF_SELECTEDIMAGE;
1538 tvIns.item.iImage = I_IMAGECALLBACK;
1539 tvIns.item.iSelectedImage = I_IMAGECALLBACK;
1540
1541 param->SetImage(image, wxTreeItemIcon_Normal);
1542 param->SetImage(selectedImage, wxTreeItemIcon_Selected);
1543
1544 mask |= TVIF_PARAM;
1545 tvIns.item.lParam = (LPARAM)param;
1546 tvIns.item.mask = mask;
1547
1548 // don't use the hack below for the children of hidden root: this results
1549 // in a crash inside comctl32.dll when we call TreeView_GetItemRect()
1550 const bool firstChild = !IsHiddenRoot(parent) &&
1551 !TreeView_GetChild(GetHwnd(), HITEM(parent));
1552
1553 HTREEITEM id = TreeView_InsertItem(GetHwnd(), &tvIns);
1554 if ( id == 0 )
1555 {
1556 wxLogLastError(wxT("TreeView_InsertItem"));
1557 }
1558
1559 // apparently some Windows versions (2000 and XP are reported to do this)
1560 // sometimes don't refresh the tree after adding the first child and so we
1561 // need this to make the "[+]" appear
1562 if ( firstChild )
1563 {
1564 RECT rect;
1565 TreeView_GetItemRect(GetHwnd(), HITEM(parent), &rect, FALSE);
1566 ::InvalidateRect(GetHwnd(), &rect, FALSE);
1567 }
1568
1569 // associate the application tree item with Win32 tree item handle
1570 param->SetItem(id);
1571
1572 // setup wxTreeItemData
1573 if ( data != NULL )
1574 {
1575 param->SetData(data);
1576 data->SetId(id);
1577 }
1578
1579 return wxTreeItemId(id);
1580 }
1581
1582 wxTreeItemId wxTreeCtrl::AddRoot(const wxString& text,
1583 int image, int selectedImage,
1584 wxTreeItemData *data)
1585 {
1586 if ( HasFlag(wxTR_HIDE_ROOT) )
1587 {
1588 wxASSERT_MSG( !m_pVirtualRoot, wxT("tree can have only a single root") );
1589
1590 // create a virtual root item, the parent for all the others
1591 wxTreeItemParam *param = new wxTreeItemParam;
1592 param->SetData(data);
1593
1594 m_pVirtualRoot = new wxVirtualNode(param);
1595
1596 return TVI_ROOT;
1597 }
1598
1599 return DoInsertAfter(wxTreeItemId(), wxTreeItemId(),
1600 text, image, selectedImage, data);
1601 }
1602
1603 wxTreeItemId wxTreeCtrl::DoInsertItem(const wxTreeItemId& parent,
1604 size_t index,
1605 const wxString& text,
1606 int image, int selectedImage,
1607 wxTreeItemData *data)
1608 {
1609 wxTreeItemId idPrev;
1610 if ( index == (size_t)-1 )
1611 {
1612 // special value: append to the end
1613 idPrev = TVI_LAST;
1614 }
1615 else // find the item from index
1616 {
1617 wxTreeItemIdValue cookie;
1618 wxTreeItemId idCur = GetFirstChild(parent, cookie);
1619 while ( index != 0 && idCur.IsOk() )
1620 {
1621 index--;
1622
1623 idPrev = idCur;
1624 idCur = GetNextChild(parent, cookie);
1625 }
1626
1627 // assert, not check: if the index is invalid, we will append the item
1628 // to the end
1629 wxASSERT_MSG( index == 0, wxT("bad index in wxTreeCtrl::InsertItem") );
1630 }
1631
1632 return DoInsertAfter(parent, idPrev, text, image, selectedImage, data);
1633 }
1634
1635 void wxTreeCtrl::Delete(const wxTreeItemId& item)
1636 {
1637 // unlock tree selections on vista, without this the
1638 // tree ctrl will eventually crash after item deletion
1639 TreeItemUnlocker unlock_all;
1640
1641 if ( HasFlag(wxTR_MULTIPLE) )
1642 {
1643 bool selected = IsSelected(item);
1644 wxTreeItemId next;
1645
1646 if ( selected )
1647 {
1648 next = TreeView_GetNextVisible(GetHwnd(), HITEM(item));
1649
1650 if ( !next.IsOk() )
1651 {
1652 next = TreeView_GetPrevVisible(GetHwnd(), HITEM(item));
1653 }
1654 }
1655
1656 {
1657 TempSetter set(m_changingSelection);
1658 if ( !TreeView_DeleteItem(GetHwnd(), HITEM(item)) )
1659 {
1660 wxLogLastError(wxT("TreeView_DeleteItem"));
1661 return;
1662 }
1663 }
1664
1665 if ( !selected )
1666 {
1667 return;
1668 }
1669
1670 if ( item == m_htSelStart )
1671 m_htSelStart.Unset();
1672
1673 if ( item == m_htClickedItem )
1674 m_htClickedItem.Unset();
1675
1676 if ( next.IsOk() )
1677 {
1678 wxTreeEvent changingEvent(wxEVT_COMMAND_TREE_SEL_CHANGING, this, next);
1679
1680 if ( IsTreeEventAllowed(changingEvent) )
1681 {
1682 wxTreeEvent changedEvent(wxEVT_COMMAND_TREE_SEL_CHANGED, this, next);
1683 (void)HandleTreeEvent(changedEvent);
1684 }
1685 else
1686 {
1687 DoUnselectItem(next);
1688 ClearFocusedItem();
1689 }
1690 }
1691 }
1692 else
1693 {
1694 if ( !TreeView_DeleteItem(GetHwnd(), HITEM(item)) )
1695 {
1696 wxLogLastError(wxT("TreeView_DeleteItem"));
1697 }
1698 }
1699 }
1700
1701 // delete all children (but don't delete the item itself)
1702 void wxTreeCtrl::DeleteChildren(const wxTreeItemId& item)
1703 {
1704 // unlock tree selections on vista for the duration of this call
1705 TreeItemUnlocker unlock_all;
1706
1707 wxTreeItemIdValue cookie;
1708
1709 wxArrayTreeItemIds children;
1710 wxTreeItemId child = GetFirstChild(item, cookie);
1711 while ( child.IsOk() )
1712 {
1713 children.Add(child);
1714
1715 child = GetNextChild(item, cookie);
1716 }
1717
1718 size_t nCount = children.Count();
1719 for ( size_t n = 0; n < nCount; n++ )
1720 {
1721 Delete(children[n]);
1722 }
1723 }
1724
1725 void wxTreeCtrl::DeleteAllItems()
1726 {
1727 // unlock tree selections on vista for the duration of this call
1728 TreeItemUnlocker unlock_all;
1729
1730 // invalidate all the items we store as they're going to become invalid
1731 m_htSelStart =
1732 m_htClickedItem = wxTreeItemId();
1733
1734 // delete the "virtual" root item.
1735 if ( GET_VIRTUAL_ROOT() )
1736 {
1737 delete GET_VIRTUAL_ROOT();
1738 m_pVirtualRoot = NULL;
1739 }
1740
1741 // and all the real items
1742
1743 if ( !TreeView_DeleteAllItems(GetHwnd()) )
1744 {
1745 wxLogLastError(wxT("TreeView_DeleteAllItems"));
1746 }
1747 }
1748
1749 void wxTreeCtrl::DoExpand(const wxTreeItemId& item, int flag)
1750 {
1751 wxASSERT_MSG( flag == TVE_COLLAPSE ||
1752 flag == (TVE_COLLAPSE | TVE_COLLAPSERESET) ||
1753 flag == TVE_EXPAND ||
1754 flag == TVE_TOGGLE,
1755 wxT("Unknown flag in wxTreeCtrl::DoExpand") );
1756
1757 // A hidden root can be neither expanded nor collapsed.
1758 wxCHECK_RET( !IsHiddenRoot(item),
1759 wxT("Can't expand/collapse hidden root node!") );
1760
1761 // TreeView_Expand doesn't send TVN_ITEMEXPAND(ING) messages, so we must
1762 // emulate them. This behaviour has changed slightly with comctl32.dll
1763 // v 4.70 - now it does send them but only the first time. To maintain
1764 // compatible behaviour and also in order to not have surprises with the
1765 // future versions, don't rely on this and still do everything ourselves.
1766 // To avoid that the messages be sent twice when the item is expanded for
1767 // the first time we must clear TVIS_EXPANDEDONCE style manually.
1768
1769 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_EXPANDEDONCE);
1770 tvItem.state = 0;
1771 DoSetItem(&tvItem);
1772
1773 if ( IsExpanded(item) )
1774 {
1775 wxTreeEvent event(wxEVT_COMMAND_TREE_ITEM_COLLAPSING,
1776 this, wxTreeItemId(item));
1777
1778 if ( !IsTreeEventAllowed(event) )
1779 return;
1780 }
1781
1782 if ( TreeView_Expand(GetHwnd(), HITEM(item), flag) )
1783 {
1784 if ( IsExpanded(item) )
1785 return;
1786
1787 wxTreeEvent event(wxEVT_COMMAND_TREE_ITEM_COLLAPSED, this, item);
1788 (void)HandleTreeEvent(event);
1789 }
1790 //else: change didn't took place, so do nothing at all
1791 }
1792
1793 void wxTreeCtrl::Expand(const wxTreeItemId& item)
1794 {
1795 DoExpand(item, TVE_EXPAND);
1796 }
1797
1798 void wxTreeCtrl::Collapse(const wxTreeItemId& item)
1799 {
1800 DoExpand(item, TVE_COLLAPSE);
1801 }
1802
1803 void wxTreeCtrl::CollapseAndReset(const wxTreeItemId& item)
1804 {
1805 DoExpand(item, TVE_COLLAPSE | TVE_COLLAPSERESET);
1806 }
1807
1808 void wxTreeCtrl::Toggle(const wxTreeItemId& item)
1809 {
1810 DoExpand(item, TVE_TOGGLE);
1811 }
1812
1813 void wxTreeCtrl::Unselect()
1814 {
1815 wxASSERT_MSG( !HasFlag(wxTR_MULTIPLE),
1816 wxT("doesn't make sense, may be you want UnselectAll()?") );
1817
1818 // the current focus
1819 HTREEITEM htFocus = (HTREEITEM)TreeView_GetSelection(GetHwnd());
1820
1821 if ( !htFocus )
1822 {
1823 return;
1824 }
1825
1826 if ( HasFlag(wxTR_MULTIPLE) )
1827 {
1828 wxTreeEvent changingEvent(wxEVT_COMMAND_TREE_SEL_CHANGING,
1829 this, wxTreeItemId());
1830 changingEvent.m_itemOld = htFocus;
1831
1832 if ( IsTreeEventAllowed(changingEvent) )
1833 {
1834 ClearFocusedItem();
1835
1836 wxTreeEvent changedEvent(wxEVT_COMMAND_TREE_SEL_CHANGED,
1837 this, wxTreeItemId());
1838 changedEvent.m_itemOld = htFocus;
1839 (void)HandleTreeEvent(changedEvent);
1840 }
1841 }
1842 else
1843 {
1844 ClearFocusedItem();
1845 }
1846 }
1847
1848 void wxTreeCtrl::DoUnselectAll()
1849 {
1850 wxArrayTreeItemIds selections;
1851 size_t count = GetSelections(selections);
1852
1853 for ( size_t n = 0; n < count; n++ )
1854 {
1855 DoUnselectItem(selections[n]);
1856 }
1857
1858 m_htSelStart.Unset();
1859 }
1860
1861 void wxTreeCtrl::UnselectAll()
1862 {
1863 if ( HasFlag(wxTR_MULTIPLE) )
1864 {
1865 HTREEITEM htFocus = (HTREEITEM)TreeView_GetSelection(GetHwnd());
1866 if ( !htFocus ) return;
1867
1868 wxTreeEvent changingEvent(wxEVT_COMMAND_TREE_SEL_CHANGING, this);
1869 changingEvent.m_itemOld = htFocus;
1870
1871 if ( IsTreeEventAllowed(changingEvent) )
1872 {
1873 DoUnselectAll();
1874
1875 wxTreeEvent changedEvent(wxEVT_COMMAND_TREE_SEL_CHANGED, this);
1876 changedEvent.m_itemOld = htFocus;
1877 (void)HandleTreeEvent(changedEvent);
1878 }
1879 }
1880 else
1881 {
1882 Unselect();
1883 }
1884 }
1885
1886 void wxTreeCtrl::DoSelectItem(const wxTreeItemId& item, bool select)
1887 {
1888 TempSetter set(m_changingSelection);
1889
1890 ::SelectItem(GetHwnd(), HITEM(item), select);
1891 }
1892
1893 void wxTreeCtrl::SelectItem(const wxTreeItemId& item, bool select)
1894 {
1895 wxCHECK_RET( !IsHiddenRoot(item), wxT("can't select hidden root item") );
1896
1897 if ( select == IsSelected(item) )
1898 {
1899 // nothing to do, the item is already in the requested state
1900 return;
1901 }
1902
1903 if ( HasFlag(wxTR_MULTIPLE) )
1904 {
1905 wxTreeEvent changingEvent(wxEVT_COMMAND_TREE_SEL_CHANGING, this, item);
1906
1907 if ( IsTreeEventAllowed(changingEvent) )
1908 {
1909 HTREEITEM htFocus = (HTREEITEM)TreeView_GetSelection(GetHwnd());
1910 DoSelectItem(item, select);
1911
1912 if ( !htFocus )
1913 {
1914 SetFocusedItem(item);
1915 }
1916
1917 wxTreeEvent changedEvent(wxEVT_COMMAND_TREE_SEL_CHANGED,
1918 this, item);
1919 (void)HandleTreeEvent(changedEvent);
1920 }
1921 }
1922 else // single selection
1923 {
1924 wxTreeItemId itemOld, itemNew;
1925 if ( select )
1926 {
1927 itemOld = GetSelection();
1928 itemNew = item;
1929 }
1930 else // deselecting the currently selected item
1931 {
1932 itemOld = item;
1933 // leave itemNew invalid
1934 }
1935
1936 // in spite of the docs (MSDN Jan 99 edition), we don't seem to receive
1937 // the notification from the control (i.e. TVN_SELCHANG{ED|ING}), so
1938 // send them ourselves
1939
1940 wxTreeEvent
1941 changingEvent(wxEVT_COMMAND_TREE_SEL_CHANGING, this, itemNew);
1942 changingEvent.SetOldItem(itemOld);
1943
1944 if ( IsTreeEventAllowed(changingEvent) )
1945 {
1946 if ( !TreeView_SelectItem(GetHwnd(), HITEM(itemNew)) )
1947 {
1948 wxLogLastError(wxT("TreeView_SelectItem"));
1949 }
1950 else // ok
1951 {
1952 SetFocusedItem(item);
1953
1954 wxTreeEvent changedEvent(wxEVT_COMMAND_TREE_SEL_CHANGED,
1955 this, itemNew);
1956 changedEvent.SetOldItem(itemOld);
1957 (void)HandleTreeEvent(changedEvent);
1958 }
1959 }
1960 //else: program vetoed the change
1961 }
1962 }
1963
1964 void wxTreeCtrl::EnsureVisible(const wxTreeItemId& item)
1965 {
1966 wxCHECK_RET( !IsHiddenRoot(item), wxT("can't show hidden root item") );
1967
1968 // no error return
1969 TreeView_EnsureVisible(GetHwnd(), HITEM(item));
1970 }
1971
1972 void wxTreeCtrl::ScrollTo(const wxTreeItemId& item)
1973 {
1974 if ( !TreeView_SelectSetFirstVisible(GetHwnd(), HITEM(item)) )
1975 {
1976 wxLogLastError(wxT("TreeView_SelectSetFirstVisible"));
1977 }
1978 }
1979
1980 wxTextCtrl *wxTreeCtrl::GetEditControl() const
1981 {
1982 return m_textCtrl;
1983 }
1984
1985 void wxTreeCtrl::DeleteTextCtrl()
1986 {
1987 if ( m_textCtrl )
1988 {
1989 // the HWND corresponding to this control is deleted by the tree
1990 // control itself and we don't know when exactly this happens, so check
1991 // if the window still exists before calling UnsubclassWin()
1992 if ( !::IsWindow(GetHwndOf(m_textCtrl)) )
1993 {
1994 m_textCtrl->SetHWND(0);
1995 }
1996
1997 m_textCtrl->UnsubclassWin();
1998 m_textCtrl->SetHWND(0);
1999 delete m_textCtrl;
2000 m_textCtrl = NULL;
2001
2002 m_idEdited.Unset();
2003 }
2004 }
2005
2006 wxTextCtrl *wxTreeCtrl::EditLabel(const wxTreeItemId& item,
2007 wxClassInfo *textControlClass)
2008 {
2009 wxASSERT( textControlClass->IsKindOf(CLASSINFO(wxTextCtrl)) );
2010
2011 DeleteTextCtrl();
2012
2013 m_idEdited = item;
2014 m_textCtrl = (wxTextCtrl *)textControlClass->CreateObject();
2015 HWND hWnd = (HWND) TreeView_EditLabel(GetHwnd(), HITEM(item));
2016
2017 // this is not an error - the TVN_BEGINLABELEDIT handler might have
2018 // returned false
2019 if ( !hWnd )
2020 {
2021 delete m_textCtrl;
2022 m_textCtrl = NULL;
2023 return NULL;
2024 }
2025
2026 // textctrl is subclassed in MSWOnNotify
2027 return m_textCtrl;
2028 }
2029
2030 // End label editing, optionally cancelling the edit
2031 void wxTreeCtrl::DoEndEditLabel(bool discardChanges)
2032 {
2033 TreeView_EndEditLabelNow(GetHwnd(), discardChanges);
2034
2035 DeleteTextCtrl();
2036 }
2037
2038 wxTreeItemId wxTreeCtrl::DoTreeHitTest(const wxPoint& point, int& flags) const
2039 {
2040 TV_HITTESTINFO hitTestInfo;
2041 hitTestInfo.pt.x = (int)point.x;
2042 hitTestInfo.pt.y = (int)point.y;
2043
2044 (void) TreeView_HitTest(GetHwnd(), &hitTestInfo);
2045
2046 flags = 0;
2047
2048 // avoid repetition
2049 #define TRANSLATE_FLAG(flag) if ( hitTestInfo.flags & TVHT_##flag ) \
2050 flags |= wxTREE_HITTEST_##flag
2051
2052 TRANSLATE_FLAG(ABOVE);
2053 TRANSLATE_FLAG(BELOW);
2054 TRANSLATE_FLAG(NOWHERE);
2055 TRANSLATE_FLAG(ONITEMBUTTON);
2056 TRANSLATE_FLAG(ONITEMICON);
2057 TRANSLATE_FLAG(ONITEMINDENT);
2058 TRANSLATE_FLAG(ONITEMLABEL);
2059 TRANSLATE_FLAG(ONITEMRIGHT);
2060 TRANSLATE_FLAG(ONITEMSTATEICON);
2061 TRANSLATE_FLAG(TOLEFT);
2062 TRANSLATE_FLAG(TORIGHT);
2063
2064 #undef TRANSLATE_FLAG
2065
2066 return wxTreeItemId(hitTestInfo.hItem);
2067 }
2068
2069 bool wxTreeCtrl::GetBoundingRect(const wxTreeItemId& item,
2070 wxRect& rect,
2071 bool textOnly) const
2072 {
2073 RECT rc;
2074
2075 // Virtual root items have no bounding rectangle
2076 if ( IS_VIRTUAL_ROOT(item) )
2077 {
2078 return false;
2079 }
2080
2081 if ( TreeView_GetItemRect(GetHwnd(), HITEM(item),
2082 &rc, textOnly) )
2083 {
2084 rect = wxRect(wxPoint(rc.left, rc.top), wxPoint(rc.right, rc.bottom));
2085
2086 return true;
2087 }
2088 else
2089 {
2090 // couldn't retrieve rect: for example, item isn't visible
2091 return false;
2092 }
2093 }
2094
2095 void wxTreeCtrl::ClearFocusedItem()
2096 {
2097 TempSetter set(m_changingSelection);
2098
2099 if ( !TreeView_SelectItem(GetHwnd(), 0) )
2100 {
2101 wxLogLastError(wxT("TreeView_SelectItem"));
2102 }
2103 }
2104
2105 void wxTreeCtrl::SetFocusedItem(const wxTreeItemId& item)
2106 {
2107 TempSetter set(m_changingSelection);
2108
2109 ::SetFocus(GetHwnd(), HITEM(item));
2110 }
2111
2112 void wxTreeCtrl::DoUnselectItem(const wxTreeItemId& item)
2113 {
2114 TempSetter set(m_changingSelection);
2115
2116 ::UnselectItem(GetHwnd(), HITEM(item));
2117 }
2118
2119 void wxTreeCtrl::DoToggleItemSelection(const wxTreeItemId& item)
2120 {
2121 TempSetter set(m_changingSelection);
2122
2123 ::ToggleItemSelection(GetHwnd(), HITEM(item));
2124 }
2125
2126 // ----------------------------------------------------------------------------
2127 // sorting stuff
2128 // ----------------------------------------------------------------------------
2129
2130 // this is just a tiny namespace which is friend to wxTreeCtrl and so can use
2131 // functions such as IsDataIndirect()
2132 class wxTreeSortHelper
2133 {
2134 public:
2135 static int CALLBACK Compare(LPARAM data1, LPARAM data2, LPARAM tree);
2136
2137 private:
2138 static wxTreeItemId GetIdFromData(LPARAM lParam)
2139 {
2140 return ((wxTreeItemParam*)lParam)->GetItem();
2141 }
2142 };
2143
2144 int CALLBACK wxTreeSortHelper::Compare(LPARAM pItem1,
2145 LPARAM pItem2,
2146 LPARAM htree)
2147 {
2148 wxCHECK_MSG( pItem1 && pItem2, 0,
2149 wxT("sorting tree without data doesn't make sense") );
2150
2151 wxTreeCtrl *tree = (wxTreeCtrl *)htree;
2152
2153 return tree->OnCompareItems(GetIdFromData(pItem1),
2154 GetIdFromData(pItem2));
2155 }
2156
2157 void wxTreeCtrl::SortChildren(const wxTreeItemId& item)
2158 {
2159 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
2160
2161 // rely on the fact that TreeView_SortChildren does the same thing as our
2162 // default behaviour, i.e. sorts items alphabetically and so call it
2163 // directly if we're not in derived class (much more efficient!)
2164 // RN: Note that if you find you're code doesn't sort as expected this
2165 // may be why as if you don't use the DECLARE_CLASS/IMPLEMENT_CLASS
2166 // combo for your derived wxTreeCtrl if will sort without
2167 // OnCompareItems
2168 if ( GetClassInfo() == CLASSINFO(wxTreeCtrl) )
2169 {
2170 TreeView_SortChildren(GetHwnd(), HITEM(item), 0);
2171 }
2172 else
2173 {
2174 TV_SORTCB tvSort;
2175 tvSort.hParent = HITEM(item);
2176 tvSort.lpfnCompare = wxTreeSortHelper::Compare;
2177 tvSort.lParam = (LPARAM)this;
2178 TreeView_SortChildrenCB(GetHwnd(), &tvSort, 0 /* reserved */);
2179 }
2180 }
2181
2182 // ----------------------------------------------------------------------------
2183 // implementation
2184 // ----------------------------------------------------------------------------
2185
2186 bool wxTreeCtrl::MSWShouldPreProcessMessage(WXMSG* msg)
2187 {
2188 if ( msg->message == WM_KEYDOWN )
2189 {
2190 // Only eat VK_RETURN if not being used by the application in
2191 // conjunction with modifiers
2192 if ( (msg->wParam == VK_RETURN) && !wxIsAnyModifierDown() )
2193 {
2194 // we need VK_RETURN to generate wxEVT_COMMAND_TREE_ITEM_ACTIVATED
2195 return false;
2196 }
2197 }
2198
2199 return wxTreeCtrlBase::MSWShouldPreProcessMessage(msg);
2200 }
2201
2202 bool wxTreeCtrl::MSWCommand(WXUINT cmd, WXWORD id_)
2203 {
2204 const int id = (signed short)id_;
2205
2206 if ( cmd == EN_UPDATE )
2207 {
2208 wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, id);
2209 event.SetEventObject( this );
2210 ProcessCommand(event);
2211 }
2212 else if ( cmd == EN_KILLFOCUS )
2213 {
2214 wxCommandEvent event(wxEVT_KILL_FOCUS, id);
2215 event.SetEventObject( this );
2216 ProcessCommand(event);
2217 }
2218 else
2219 {
2220 // nothing done
2221 return false;
2222 }
2223
2224 // command processed
2225 return true;
2226 }
2227
2228 bool wxTreeCtrl::MSWIsOnItem(unsigned flags) const
2229 {
2230 unsigned mask = TVHT_ONITEM;
2231 if ( HasFlag(wxTR_FULL_ROW_HIGHLIGHT) )
2232 mask |= TVHT_ONITEMINDENT | TVHT_ONITEMRIGHT;
2233
2234 return (flags & mask) != 0;
2235 }
2236
2237 bool wxTreeCtrl::MSWHandleSelectionKey(unsigned vkey)
2238 {
2239 const bool bCtrl = wxIsCtrlDown();
2240 const bool bShift = wxIsShiftDown();
2241 const HTREEITEM htSel = (HTREEITEM)TreeView_GetSelection(GetHwnd());
2242
2243 switch ( vkey )
2244 {
2245 case VK_RETURN:
2246 case VK_SPACE:
2247 if ( !htSel )
2248 break;
2249
2250 if ( vkey != VK_RETURN && bCtrl )
2251 {
2252 wxTreeEvent changingEvent(wxEVT_COMMAND_TREE_SEL_CHANGING,
2253 this, htSel);
2254 changingEvent.m_itemOld = htSel;
2255
2256 if ( IsTreeEventAllowed(changingEvent) )
2257 {
2258 DoToggleItemSelection(wxTreeItemId(htSel));
2259
2260 wxTreeEvent changedEvent(wxEVT_COMMAND_TREE_SEL_CHANGED,
2261 this, htSel);
2262 changedEvent.m_itemOld = htSel;
2263 (void)HandleTreeEvent(changedEvent);
2264 }
2265 }
2266 else
2267 {
2268 wxArrayTreeItemIds selections;
2269 size_t count = GetSelections(selections);
2270
2271 if ( count != 1 || HITEM(selections[0]) != htSel )
2272 {
2273 wxTreeEvent changingEvent(wxEVT_COMMAND_TREE_SEL_CHANGING,
2274 this, htSel);
2275 changingEvent.m_itemOld = htSel;
2276
2277 if ( IsTreeEventAllowed(changingEvent) )
2278 {
2279 DoUnselectAll();
2280 DoSelectItem(wxTreeItemId(htSel));
2281
2282 wxTreeEvent changedEvent(wxEVT_COMMAND_TREE_SEL_CHANGED,
2283 this, htSel);
2284 changedEvent.m_itemOld = htSel;
2285 (void)HandleTreeEvent(changedEvent);
2286 }
2287 }
2288 }
2289 break;
2290
2291 case VK_UP:
2292 case VK_DOWN:
2293 if ( !bCtrl && !bShift )
2294 {
2295 wxArrayTreeItemIds selections;
2296 wxTreeItemId next;
2297
2298 if ( htSel )
2299 {
2300 next = vkey == VK_UP
2301 ? TreeView_GetPrevVisible(GetHwnd(), htSel)
2302 : TreeView_GetNextVisible(GetHwnd(), htSel);
2303 }
2304 else
2305 {
2306 next = GetRootItem();
2307
2308 if ( IsHiddenRoot(next) )
2309 next = TreeView_GetChild(GetHwnd(), HITEM(next));
2310 }
2311
2312 if ( !next.IsOk() )
2313 {
2314 break;
2315 }
2316
2317 wxTreeEvent changingEvent(wxEVT_COMMAND_TREE_SEL_CHANGING,
2318 this, next);
2319 changingEvent.m_itemOld = htSel;
2320
2321 if ( IsTreeEventAllowed(changingEvent) )
2322 {
2323 DoUnselectAll();
2324 DoSelectItem(next);
2325 SetFocusedItem(next);
2326
2327 wxTreeEvent changedEvent(wxEVT_COMMAND_TREE_SEL_CHANGED,
2328 this, next);
2329 changedEvent.m_itemOld = htSel;
2330 (void)HandleTreeEvent(changedEvent);
2331 }
2332 }
2333 else if ( htSel )
2334 {
2335 wxTreeItemId next = vkey == VK_UP
2336 ? TreeView_GetPrevVisible(GetHwnd(), htSel)
2337 : TreeView_GetNextVisible(GetHwnd(), htSel);
2338
2339 if ( !next.IsOk() )
2340 {
2341 break;
2342 }
2343
2344 if ( !m_htSelStart )
2345 {
2346 m_htSelStart = htSel;
2347 }
2348
2349 if ( bShift && SelectRange(GetHwnd(), HITEM(m_htSelStart), HITEM(next),
2350 SR_UNSELECT_OTHERS | SR_SIMULATE) )
2351 {
2352 wxTreeEvent changingEvent(wxEVT_COMMAND_TREE_SEL_CHANGING, this, next);
2353 changingEvent.m_itemOld = htSel;
2354
2355 if ( IsTreeEventAllowed(changingEvent) )
2356 {
2357 SelectRange(GetHwnd(), HITEM(m_htSelStart), HITEM(next),
2358 SR_UNSELECT_OTHERS);
2359
2360 wxTreeEvent changedEvent(wxEVT_COMMAND_TREE_SEL_CHANGED, this, next);
2361 changedEvent.m_itemOld = htSel;
2362 (void)HandleTreeEvent(changedEvent);
2363 }
2364 }
2365
2366 SetFocusedItem(next);
2367 }
2368 break;
2369
2370 case VK_LEFT:
2371 if ( HasChildren(htSel) && IsExpanded(htSel) )
2372 {
2373 Collapse(htSel);
2374 }
2375 else
2376 {
2377 wxTreeItemId next = GetItemParent(htSel);
2378
2379 if ( next.IsOk() && !IsHiddenRoot(next) )
2380 {
2381 wxTreeEvent changingEvent(wxEVT_COMMAND_TREE_SEL_CHANGING,
2382 this, next);
2383 changingEvent.m_itemOld = htSel;
2384
2385 if ( IsTreeEventAllowed(changingEvent) )
2386 {
2387 DoUnselectAll();
2388 DoSelectItem(next);
2389 SetFocusedItem(next);
2390
2391 wxTreeEvent changedEvent(wxEVT_COMMAND_TREE_SEL_CHANGED,
2392 this, next);
2393 changedEvent.m_itemOld = htSel;
2394 (void)HandleTreeEvent(changedEvent);
2395 }
2396 }
2397 }
2398 break;
2399
2400 case VK_RIGHT:
2401 if ( !IsVisible(htSel) )
2402 {
2403 EnsureVisible(htSel);
2404 }
2405
2406 if ( !HasChildren(htSel) )
2407 break;
2408
2409 if ( !IsExpanded(htSel) )
2410 {
2411 Expand(htSel);
2412 }
2413 else
2414 {
2415 wxTreeItemId next = TreeView_GetChild(GetHwnd(), htSel);
2416
2417 wxTreeEvent changingEvent(wxEVT_COMMAND_TREE_SEL_CHANGING, this, next);
2418 changingEvent.m_itemOld = htSel;
2419
2420 if ( IsTreeEventAllowed(changingEvent) )
2421 {
2422 DoUnselectAll();
2423 DoSelectItem(next);
2424 SetFocusedItem(next);
2425
2426 wxTreeEvent changedEvent(wxEVT_COMMAND_TREE_SEL_CHANGED, this, next);
2427 changedEvent.m_itemOld = htSel;
2428 (void)HandleTreeEvent(changedEvent);
2429 }
2430 }
2431 break;
2432
2433 case VK_HOME:
2434 case VK_END:
2435 {
2436 wxTreeItemId next = GetRootItem();
2437
2438 if ( IsHiddenRoot(next) )
2439 {
2440 next = TreeView_GetChild(GetHwnd(), HITEM(next));
2441 }
2442
2443 if ( !next.IsOk() )
2444 break;
2445
2446 if ( vkey == VK_END )
2447 {
2448 for ( ;; )
2449 {
2450 wxTreeItemId nextTemp = TreeView_GetNextVisible(
2451 GetHwnd(), HITEM(next));
2452
2453 if ( !nextTemp.IsOk() )
2454 break;
2455
2456 next = nextTemp;
2457 }
2458 }
2459
2460 if ( htSel == HITEM(next) )
2461 break;
2462
2463 if ( bShift )
2464 {
2465 if ( !m_htSelStart )
2466 {
2467 m_htSelStart = htSel;
2468 }
2469
2470 if ( SelectRange(GetHwnd(),
2471 HITEM(m_htSelStart), HITEM(next),
2472 SR_UNSELECT_OTHERS | SR_SIMULATE) )
2473 {
2474 wxTreeEvent changingEvent(wxEVT_COMMAND_TREE_SEL_CHANGING,
2475 this, next);
2476 changingEvent.m_itemOld = htSel;
2477
2478 if ( IsTreeEventAllowed(changingEvent) )
2479 {
2480 SelectRange(GetHwnd(),
2481 HITEM(m_htSelStart), HITEM(next),
2482 SR_UNSELECT_OTHERS);
2483 SetFocusedItem(next);
2484
2485 wxTreeEvent changedEvent(wxEVT_COMMAND_TREE_SEL_CHANGED,
2486 this, next);
2487 changedEvent.m_itemOld = htSel;
2488 (void)HandleTreeEvent(changedEvent);
2489 }
2490 }
2491 }
2492 else // no Shift
2493 {
2494 wxTreeEvent changingEvent(wxEVT_COMMAND_TREE_SEL_CHANGING,
2495 this, next);
2496 changingEvent.m_itemOld = htSel;
2497
2498 if ( IsTreeEventAllowed(changingEvent) )
2499 {
2500 DoUnselectAll();
2501 DoSelectItem(next);
2502 SetFocusedItem(next);
2503
2504 wxTreeEvent changedEvent(wxEVT_COMMAND_TREE_SEL_CHANGED,
2505 this, next);
2506 changedEvent.m_itemOld = htSel;
2507 (void)HandleTreeEvent(changedEvent);
2508 }
2509 }
2510 }
2511 break;
2512
2513 case VK_PRIOR:
2514 case VK_NEXT:
2515 if ( bCtrl )
2516 {
2517 wxTreeItemId firstVisible = GetFirstVisibleItem();
2518 size_t visibleCount = TreeView_GetVisibleCount(GetHwnd());
2519 wxTreeItemId nextAdjacent = (vkey == VK_PRIOR) ?
2520 TreeView_GetPrevVisible(GetHwnd(), HITEM(firstVisible)) :
2521 TreeView_GetNextVisible(GetHwnd(), HITEM(firstVisible));
2522
2523 if ( !nextAdjacent )
2524 {
2525 break;
2526 }
2527
2528 wxTreeItemId nextStart = firstVisible;
2529
2530 for ( size_t n = 1; n < visibleCount; n++ )
2531 {
2532 wxTreeItemId nextTemp = (vkey == VK_PRIOR) ?
2533 TreeView_GetPrevVisible(GetHwnd(), HITEM(nextStart)) :
2534 TreeView_GetNextVisible(GetHwnd(), HITEM(nextStart));
2535
2536 if ( nextTemp.IsOk() )
2537 {
2538 nextStart = nextTemp;
2539 }
2540 else
2541 {
2542 break;
2543 }
2544 }
2545
2546 EnsureVisible(nextStart);
2547
2548 if ( vkey == VK_NEXT )
2549 {
2550 wxTreeItemId nextEnd = nextStart;
2551
2552 for ( size_t n = 1; n < visibleCount; n++ )
2553 {
2554 wxTreeItemId nextTemp =
2555 TreeView_GetNextVisible(GetHwnd(), HITEM(nextEnd));
2556
2557 if ( nextTemp.IsOk() )
2558 {
2559 nextEnd = nextTemp;
2560 }
2561 else
2562 {
2563 break;
2564 }
2565 }
2566
2567 EnsureVisible(nextEnd);
2568 }
2569 }
2570 else // no Ctrl
2571 {
2572 size_t visibleCount = TreeView_GetVisibleCount(GetHwnd());
2573 wxTreeItemId nextAdjacent = (vkey == VK_PRIOR) ?
2574 TreeView_GetPrevVisible(GetHwnd(), htSel) :
2575 TreeView_GetNextVisible(GetHwnd(), htSel);
2576
2577 if ( !nextAdjacent )
2578 {
2579 break;
2580 }
2581
2582 wxTreeItemId next(htSel);
2583
2584 for ( size_t n = 1; n < visibleCount; n++ )
2585 {
2586 wxTreeItemId nextTemp = vkey == VK_PRIOR ?
2587 TreeView_GetPrevVisible(GetHwnd(), HITEM(next)) :
2588 TreeView_GetNextVisible(GetHwnd(), HITEM(next));
2589
2590 if ( !nextTemp.IsOk() )
2591 break;
2592
2593 next = nextTemp;
2594 }
2595
2596 wxTreeEvent changingEvent(wxEVT_COMMAND_TREE_SEL_CHANGING,
2597 this, next);
2598 changingEvent.m_itemOld = htSel;
2599
2600 if ( IsTreeEventAllowed(changingEvent) )
2601 {
2602 DoUnselectAll();
2603 m_htSelStart.Unset();
2604 DoSelectItem(next);
2605 SetFocusedItem(next);
2606
2607 wxTreeEvent changedEvent(wxEVT_COMMAND_TREE_SEL_CHANGED,
2608 this, next);
2609 changedEvent.m_itemOld = htSel;
2610 (void)HandleTreeEvent(changedEvent);
2611 }
2612 }
2613 break;
2614
2615 default:
2616 return false;
2617 }
2618
2619 return true;
2620 }
2621
2622 bool wxTreeCtrl::MSWHandleTreeKeyDownEvent(WXWPARAM wParam, WXLPARAM lParam)
2623 {
2624 wxTreeEvent keyEvent(wxEVT_COMMAND_TREE_KEY_DOWN, this);
2625
2626 int keyCode = wxCharCodeMSWToWX(wParam);
2627
2628 if ( !keyCode )
2629 {
2630 // wxCharCodeMSWToWX() returns 0 to indicate that this is a
2631 // simple ASCII key
2632 keyCode = wParam;
2633 }
2634
2635 keyEvent.m_evtKey = CreateKeyEvent(wxEVT_KEY_DOWN, keyCode,
2636 lParam, wParam);
2637
2638 bool processed = HandleTreeEvent(keyEvent);
2639
2640 // generate a separate event for Space/Return
2641 if ( !wxIsCtrlDown() && !wxIsShiftDown() && !wxIsAltDown() &&
2642 ((wParam == VK_SPACE) || (wParam == VK_RETURN)) )
2643 {
2644 const HTREEITEM htSel = (HTREEITEM)TreeView_GetSelection(GetHwnd());
2645 if ( htSel )
2646 {
2647 wxTreeEvent activatedEvent(wxEVT_COMMAND_TREE_ITEM_ACTIVATED,
2648 this, htSel);
2649 (void)HandleTreeEvent(activatedEvent);
2650 }
2651 }
2652
2653 return processed;
2654 }
2655
2656 // we hook into WndProc to process WM_MOUSEMOVE/WM_BUTTONUP messages - as we
2657 // only do it during dragging, minimize wxWin overhead (this is important for
2658 // WM_MOUSEMOVE as they're a lot of them) by catching Windows messages directly
2659 // instead of passing by wxWin events
2660 WXLRESULT
2661 wxTreeCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
2662 {
2663 bool processed = false;
2664 WXLRESULT rc = 0;
2665 bool isMultiple = HasFlag(wxTR_MULTIPLE);
2666
2667 if ( nMsg == WM_CONTEXTMENU )
2668 {
2669 int x = GET_X_LPARAM(lParam),
2670 y = GET_Y_LPARAM(lParam);
2671
2672 // the item for which the menu should be shown
2673 wxTreeItemId item;
2674
2675 // the position where the menu should be shown in client coordinates
2676 // (so that it can be passed directly to PopupMenu())
2677 wxPoint pt;
2678
2679 if ( x == -1 || y == -1 )
2680 {
2681 // this means that the event was generated from keyboard (e.g. with
2682 // Shift-F10 or special Windows menu key)
2683 //
2684 // use the Explorer standard of putting the menu at the left edge
2685 // of the text, in the vertical middle of the text
2686 item = wxTreeItemId(TreeView_GetSelection(GetHwnd()));
2687 if ( item.IsOk() )
2688 {
2689 // Use the bounding rectangle of only the text part
2690 wxRect rect;
2691 GetBoundingRect(item, rect, true);
2692 pt = wxPoint(rect.GetX(), rect.GetY() + rect.GetHeight() / 2);
2693 }
2694 }
2695 else // event from mouse, use mouse position
2696 {
2697 pt = ScreenToClient(wxPoint(x, y));
2698
2699 TV_HITTESTINFO tvhti;
2700 tvhti.pt.x = pt.x;
2701 tvhti.pt.y = pt.y;
2702
2703 if ( TreeView_HitTest(GetHwnd(), &tvhti) )
2704 item = wxTreeItemId(tvhti.hItem);
2705 }
2706
2707 // create the event
2708 wxTreeEvent event(wxEVT_COMMAND_TREE_ITEM_MENU, this, item);
2709
2710 event.m_pointDrag = pt;
2711
2712 if ( HandleTreeEvent(event) )
2713 processed = true;
2714 //else: continue with generating wxEVT_CONTEXT_MENU in base class code
2715 }
2716 else if ( (nMsg >= WM_MOUSEFIRST) && (nMsg <= WM_MOUSELAST) )
2717 {
2718 // we only process mouse messages here and these parameters have the
2719 // same meaning for all of them
2720 int x = GET_X_LPARAM(lParam),
2721 y = GET_Y_LPARAM(lParam);
2722
2723 TV_HITTESTINFO tvht;
2724 tvht.pt.x = x;
2725 tvht.pt.y = y;
2726
2727 HTREEITEM htOldItem = TreeView_GetSelection(GetHwnd());
2728 HTREEITEM htItem = TreeView_HitTest(GetHwnd(), &tvht);
2729
2730 switch ( nMsg )
2731 {
2732 case WM_LBUTTONDOWN:
2733 if ( !isMultiple )
2734 break;
2735
2736 m_htClickedItem.Unset();
2737
2738 if ( !MSWIsOnItem(tvht.flags) )
2739 {
2740 if ( tvht.flags & TVHT_ONITEMBUTTON )
2741 {
2742 // either it's going to be handled by user code or
2743 // we're going to use it ourselves to toggle the
2744 // branch, in either case don't pass it to the base
2745 // class which would generate another mouse click event
2746 // for it even though it's already handled here
2747 processed = true;
2748 SetFocus();
2749
2750 if ( !HandleMouseEvent(nMsg, x, y, wParam) )
2751 {
2752 if ( !IsExpanded(htItem) )
2753 {
2754 Expand(htItem);
2755 }
2756 else
2757 {
2758 Collapse(htItem);
2759 }
2760 }
2761 }
2762
2763 m_focusLost = false;
2764 break;
2765 }
2766
2767 processed = true;
2768 SetFocus();
2769 m_htClickedItem = (WXHTREEITEM) htItem;
2770 m_ptClick = wxPoint(x, y);
2771
2772 if ( wParam & MK_CONTROL )
2773 {
2774 if ( HandleMouseEvent(nMsg, x, y, wParam) )
2775 {
2776 m_htClickedItem.Unset();
2777 break;
2778 }
2779
2780 wxTreeEvent changingEvent(wxEVT_COMMAND_TREE_SEL_CHANGING,
2781 this, htItem);
2782 changingEvent.m_itemOld = htOldItem;
2783
2784 if ( IsTreeEventAllowed(changingEvent) )
2785 {
2786 // toggle selected state
2787 DoToggleItemSelection(wxTreeItemId(htItem));
2788
2789 SetFocusedItem(wxTreeItemId(htItem));
2790
2791 // reset on any click without Shift
2792 m_htSelStart.Unset();
2793
2794 wxTreeEvent changedEvent(wxEVT_COMMAND_TREE_SEL_CHANGED,
2795 this, htItem);
2796 changedEvent.m_itemOld = htOldItem;
2797 (void)HandleTreeEvent(changedEvent);
2798 }
2799 }
2800 else if ( wParam & MK_SHIFT )
2801 {
2802 if ( HandleMouseEvent(nMsg, x, y, wParam) )
2803 {
2804 m_htClickedItem.Unset();
2805 break;
2806 }
2807
2808 int srFlags = 0;
2809 bool willChange = true;
2810
2811 if ( !(wParam & MK_CONTROL) )
2812 {
2813 srFlags |= SR_UNSELECT_OTHERS;
2814 }
2815
2816 if ( !m_htSelStart )
2817 {
2818 // take the focused item
2819 m_htSelStart = htOldItem;
2820 }
2821 else
2822 {
2823 willChange = SelectRange(GetHwnd(), HITEM(m_htSelStart),
2824 htItem, srFlags | SR_SIMULATE);
2825 }
2826
2827 if ( willChange )
2828 {
2829 wxTreeEvent changingEvent(wxEVT_COMMAND_TREE_SEL_CHANGING,
2830 this, htItem);
2831 changingEvent.m_itemOld = htOldItem;
2832
2833 if ( IsTreeEventAllowed(changingEvent) )
2834 {
2835 // this selects all items between the starting one
2836 // and the current
2837 if ( m_htSelStart )
2838 {
2839 SelectRange(GetHwnd(), HITEM(m_htSelStart),
2840 htItem, srFlags);
2841 }
2842 else
2843 {
2844 DoSelectItem(wxTreeItemId(htItem));
2845 }
2846
2847 SetFocusedItem(wxTreeItemId(htItem));
2848
2849 wxTreeEvent changedEvent(wxEVT_COMMAND_TREE_SEL_CHANGED,
2850 this, htItem);
2851 changedEvent.m_itemOld = htOldItem;
2852 (void)HandleTreeEvent(changedEvent);
2853 }
2854 }
2855 }
2856 else // normal click
2857 {
2858 // avoid doing anything if we click on the only
2859 // currently selected item
2860
2861 wxArrayTreeItemIds selections;
2862 size_t count = GetSelections(selections);
2863
2864 if ( count == 0 ||
2865 count > 1 ||
2866 HITEM(selections[0]) != htItem )
2867 {
2868 if ( HandleMouseEvent(nMsg, x, y, wParam) )
2869 {
2870 m_htClickedItem.Unset();
2871 break;
2872 }
2873
2874 // clear the previously selected items, if the user
2875 // clicked outside of the present selection, otherwise,
2876 // perform the deselection on mouse-up, this allows
2877 // multiple drag and drop to work.
2878 if ( !IsItemSelected(GetHwnd(), htItem))
2879 {
2880 wxTreeEvent changingEvent(wxEVT_COMMAND_TREE_SEL_CHANGING,
2881 this, htItem);
2882 changingEvent.m_itemOld = htOldItem;
2883
2884 if ( IsTreeEventAllowed(changingEvent) )
2885 {
2886 DoUnselectAll();
2887 DoSelectItem(wxTreeItemId(htItem));
2888 SetFocusedItem(wxTreeItemId(htItem));
2889
2890 wxTreeEvent changedEvent(wxEVT_COMMAND_TREE_SEL_CHANGED,
2891 this, htItem);
2892 changedEvent.m_itemOld = htOldItem;
2893 (void)HandleTreeEvent(changedEvent);
2894 }
2895 }
2896 else
2897 {
2898 SetFocusedItem(wxTreeItemId(htItem));
2899 m_mouseUpDeselect = true;
2900 }
2901 }
2902 else // click on a single selected item
2903 {
2904 // don't interfere with the default processing in
2905 // WM_MOUSEMOVE handler below as the default window
2906 // proc will start the drag itself if we let have
2907 // WM_LBUTTONDOWN
2908 m_htClickedItem.Unset();
2909
2910 // prevent in-place editing from starting if focus lost
2911 // since previous click
2912 if ( m_focusLost )
2913 {
2914 ClearFocusedItem();
2915 DoSelectItem(wxTreeItemId(htItem));
2916 SetFocusedItem(wxTreeItemId(htItem));
2917 }
2918 else
2919 {
2920 processed = false;
2921 }
2922 }
2923
2924 // reset on any click without Shift
2925 m_htSelStart.Unset();
2926 }
2927
2928 m_focusLost = false;
2929
2930 // we consumed the event so we need to trigger state image
2931 // click if needed
2932 if ( processed )
2933 {
2934 int htFlags = 0;
2935 wxTreeItemId item = HitTest(wxPoint(x, y), htFlags);
2936
2937 if ( htFlags & wxTREE_HITTEST_ONITEMSTATEICON )
2938 {
2939 m_triggerStateImageClick = true;
2940 }
2941 }
2942 break;
2943
2944 case WM_RBUTTONDOWN:
2945 if ( !isMultiple )
2946 break;
2947
2948 processed = true;
2949 SetFocus();
2950
2951 if ( HandleMouseEvent(nMsg, x, y, wParam) || !htItem )
2952 {
2953 break;
2954 }
2955
2956 // default handler removes the highlight from the currently
2957 // focused item when right mouse button is pressed on another
2958 // one but keeps the remaining items highlighted, which is
2959 // confusing, so override this default behaviour
2960 if ( !IsItemSelected(GetHwnd(), htItem) )
2961 {
2962 wxTreeEvent changingEvent(wxEVT_COMMAND_TREE_SEL_CHANGING,
2963 this, htItem);
2964 changingEvent.m_itemOld = htOldItem;
2965
2966 if ( IsTreeEventAllowed(changingEvent) )
2967 {
2968 DoUnselectAll();
2969 DoSelectItem(wxTreeItemId(htItem));
2970 SetFocusedItem(wxTreeItemId(htItem));
2971
2972 wxTreeEvent changedEvent(wxEVT_COMMAND_TREE_SEL_CHANGED,
2973 this, htItem);
2974 changedEvent.m_itemOld = htOldItem;
2975 (void)HandleTreeEvent(changedEvent);
2976 }
2977 }
2978
2979 break;
2980
2981 case WM_MOUSEMOVE:
2982 #ifndef __WXWINCE__
2983 if ( m_htClickedItem )
2984 {
2985 int cx = abs(m_ptClick.x - x);
2986 int cy = abs(m_ptClick.y - y);
2987
2988 if ( cx > ::GetSystemMetrics(SM_CXDRAG) ||
2989 cy > ::GetSystemMetrics(SM_CYDRAG) )
2990 {
2991 NM_TREEVIEW tv;
2992 wxZeroMemory(tv);
2993
2994 tv.hdr.hwndFrom = GetHwnd();
2995 tv.hdr.idFrom = ::GetWindowLong(GetHwnd(), GWL_ID);
2996 tv.hdr.code = TVN_BEGINDRAG;
2997
2998 tv.itemNew.hItem = HITEM(m_htClickedItem);
2999
3000
3001 TVITEM tviAux;
3002 wxZeroMemory(tviAux);
3003
3004 tviAux.hItem = HITEM(m_htClickedItem);
3005 tviAux.mask = TVIF_STATE | TVIF_PARAM;
3006 tviAux.stateMask = 0xffffffff;
3007 TreeView_GetItem(GetHwnd(), &tviAux);
3008
3009 tv.itemNew.state = tviAux.state;
3010 tv.itemNew.lParam = tviAux.lParam;
3011
3012 tv.ptDrag.x = x;
3013 tv.ptDrag.y = y;
3014
3015 // do it before SendMessage() call below to avoid
3016 // reentrancies here if there is another WM_MOUSEMOVE
3017 // in the queue already
3018 m_htClickedItem.Unset();
3019
3020 ::SendMessage(GetHwndOf(GetParent()), WM_NOTIFY,
3021 tv.hdr.idFrom, (LPARAM)&tv );
3022
3023 // don't pass it to the default window proc, it would
3024 // start dragging again
3025 processed = true;
3026 }
3027 }
3028 #endif // __WXWINCE__
3029
3030 #if wxUSE_DRAGIMAGE
3031 if ( m_dragImage )
3032 {
3033 m_dragImage->Move(wxPoint(x, y));
3034 if ( htItem )
3035 {
3036 // highlight the item as target (hiding drag image is
3037 // necessary - otherwise the display will be corrupted)
3038 m_dragImage->Hide();
3039 TreeView_SelectDropTarget(GetHwnd(), htItem);
3040 m_dragImage->Show();
3041 }
3042 }
3043 #endif // wxUSE_DRAGIMAGE
3044 break;
3045
3046 case WM_LBUTTONUP:
3047 if ( isMultiple )
3048 {
3049 // deselect other items if needed
3050 if ( htItem )
3051 {
3052 if ( m_mouseUpDeselect )
3053 {
3054 m_mouseUpDeselect = false;
3055
3056 wxTreeEvent changingEvent(wxEVT_COMMAND_TREE_SEL_CHANGING,
3057 this, htItem);
3058 changingEvent.m_itemOld = htOldItem;
3059
3060 if ( IsTreeEventAllowed(changingEvent) )
3061 {
3062 DoUnselectAll();
3063 DoSelectItem(wxTreeItemId(htItem));
3064 SetFocusedItem(wxTreeItemId(htItem));
3065
3066 wxTreeEvent changedEvent(wxEVT_COMMAND_TREE_SEL_CHANGED,
3067 this, htItem);
3068 changedEvent.m_itemOld = htOldItem;
3069 (void)HandleTreeEvent(changedEvent);
3070 }
3071 }
3072 }
3073
3074 m_htClickedItem.Unset();
3075
3076 if ( m_triggerStateImageClick )
3077 {
3078 if ( tvht.flags & TVHT_ONITEMSTATEICON )
3079 {
3080 wxTreeEvent event(wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK,
3081 this, htItem);
3082 (void)HandleTreeEvent(event);
3083
3084 m_triggerStateImageClick = false;
3085 processed = true;
3086 }
3087 }
3088
3089 if ( !m_dragStarted && MSWIsOnItem(tvht.flags) )
3090 {
3091 processed = true;
3092 }
3093 }
3094
3095 // fall through
3096
3097 case WM_RBUTTONUP:
3098 #if wxUSE_DRAGIMAGE
3099 if ( m_dragImage )
3100 {
3101 m_dragImage->EndDrag();
3102 delete m_dragImage;
3103 m_dragImage = NULL;
3104
3105 // generate the drag end event
3106 wxTreeEvent event(wxEVT_COMMAND_TREE_END_DRAG,
3107 this, htItem);
3108 event.m_pointDrag = wxPoint(x, y);
3109 (void)HandleTreeEvent(event);
3110
3111 // if we don't do it, the tree seems to think that 2 items
3112 // are selected simultaneously which is quite weird
3113 TreeView_SelectDropTarget(GetHwnd(), 0);
3114 }
3115 #endif // wxUSE_DRAGIMAGE
3116
3117 if ( isMultiple && nMsg == WM_RBUTTONUP )
3118 {
3119 // send NM_RCLICK
3120 NMHDR nmhdr;
3121 nmhdr.hwndFrom = GetHwnd();
3122 nmhdr.idFrom = ::GetWindowLong(GetHwnd(), GWL_ID);
3123 nmhdr.code = NM_RCLICK;
3124 ::SendMessage(::GetParent(GetHwnd()), WM_NOTIFY,
3125 nmhdr.idFrom, (LPARAM)&nmhdr);
3126 processed = true;
3127 }
3128
3129 m_dragStarted = false;
3130
3131 break;
3132 }
3133 }
3134 else if ( (nMsg == WM_SETFOCUS || nMsg == WM_KILLFOCUS) )
3135 {
3136 if ( isMultiple )
3137 {
3138 // the tree control greys out the selected item when it loses focus
3139 // and paints it as selected again when it regains it, but it won't
3140 // do it for the other items itself - help it
3141 wxArrayTreeItemIds selections;
3142 size_t count = GetSelections(selections);
3143 RECT rect;
3144
3145 for ( size_t n = 0; n < count; n++ )
3146 {
3147 // TreeView_GetItemRect() will return false if item is not
3148 // visible, which may happen perfectly well
3149 if ( TreeView_GetItemRect(GetHwnd(), HITEM(selections[n]),
3150 &rect, TRUE) )
3151 {
3152 ::InvalidateRect(GetHwnd(), &rect, FALSE);
3153 }
3154 }
3155 }
3156
3157 if ( nMsg == WM_KILLFOCUS )
3158 {
3159 m_focusLost = true;
3160 }
3161 }
3162 else if ( (nMsg == WM_KEYDOWN || nMsg == WM_SYSKEYDOWN) && isMultiple )
3163 {
3164 // normally we want to generate wxEVT_KEY_DOWN events from TVN_KEYDOWN
3165 // notification but for the keys which can be used to change selection
3166 // we need to do it from here so as to not apply the default behaviour
3167 // if the events are handled by the user code
3168 switch ( wParam )
3169 {
3170 case VK_RETURN:
3171 case VK_SPACE:
3172 case VK_UP:
3173 case VK_DOWN:
3174 case VK_LEFT:
3175 case VK_RIGHT:
3176 case VK_HOME:
3177 case VK_END:
3178 case VK_PRIOR:
3179 case VK_NEXT:
3180 if ( !HandleKeyDown(wParam, lParam) &&
3181 !MSWHandleTreeKeyDownEvent(wParam, lParam) )
3182 {
3183 // use the key to update the selection if it was left
3184 // unprocessed
3185 MSWHandleSelectionKey(wParam);
3186 }
3187
3188 // pretend that we did process it in any case as we already
3189 // generated an event for it
3190 processed = true;
3191
3192 //default: for all the other keys leave processed as false so that
3193 // the tree control generates a TVN_KEYDOWN for us
3194 }
3195
3196 }
3197 else if ( nMsg == WM_COMMAND )
3198 {
3199 // if we receive a EN_KILLFOCUS command from the in-place edit control
3200 // used for label editing, make sure to end editing
3201 WORD id, cmd;
3202 WXHWND hwnd;
3203 UnpackCommand(wParam, lParam, &id, &hwnd, &cmd);
3204
3205 if ( cmd == EN_KILLFOCUS )
3206 {
3207 if ( m_textCtrl && m_textCtrl->GetHandle() == hwnd )
3208 {
3209 DoEndEditLabel();
3210
3211 processed = true;
3212 }
3213 }
3214 }
3215
3216 if ( !processed )
3217 rc = wxControl::MSWWindowProc(nMsg, wParam, lParam);
3218
3219 return rc;
3220 }
3221
3222 WXLRESULT
3223 wxTreeCtrl::MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
3224 {
3225 if ( nMsg == WM_CHAR )
3226 {
3227 // don't let the control process Space and Return keys because it
3228 // doesn't do anything useful with them anyhow but always beeps
3229 // annoyingly when it receives them and there is no way to turn it off
3230 // simply if you just process TREEITEM_ACTIVATED event to which Space
3231 // and Enter presses are mapped in your code
3232 if ( wParam == VK_SPACE || wParam == VK_RETURN )
3233 return 0;
3234 }
3235 #if wxUSE_DRAGIMAGE
3236 else if ( nMsg == WM_KEYDOWN )
3237 {
3238 if ( wParam == VK_ESCAPE )
3239 {
3240 if ( m_dragImage )
3241 {
3242 m_dragImage->EndDrag();
3243 delete m_dragImage;
3244 m_dragImage = NULL;
3245
3246 // if we don't do it, the tree seems to think that 2 items
3247 // are selected simultaneously which is quite weird
3248 TreeView_SelectDropTarget(GetHwnd(), 0);
3249 }
3250 }
3251 }
3252 #endif // wxUSE_DRAGIMAGE
3253
3254 return wxControl::MSWDefWindowProc(nMsg, wParam, lParam);
3255 }
3256
3257 // process WM_NOTIFY Windows message
3258 bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
3259 {
3260 wxTreeEvent event(wxEVT_NULL, this);
3261 wxEventType eventType = wxEVT_NULL;
3262 NMHDR *hdr = (NMHDR *)lParam;
3263
3264 switch ( hdr->code )
3265 {
3266 case TVN_BEGINDRAG:
3267 eventType = wxEVT_COMMAND_TREE_BEGIN_DRAG;
3268 // fall through
3269
3270 case TVN_BEGINRDRAG:
3271 {
3272 if ( eventType == wxEVT_NULL )
3273 eventType = wxEVT_COMMAND_TREE_BEGIN_RDRAG;
3274 //else: left drag, already set above
3275
3276 NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
3277
3278 event.m_item = tv->itemNew.hItem;
3279 event.m_pointDrag = wxPoint(tv->ptDrag.x, tv->ptDrag.y);
3280
3281 // don't allow dragging by default: the user code must
3282 // explicitly say that it wants to allow it to avoid breaking
3283 // the old apps
3284 event.Veto();
3285 }
3286 break;
3287
3288 case TVN_BEGINLABELEDIT:
3289 {
3290 eventType = wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT;
3291 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
3292
3293 // although the user event handler may still veto it, it is
3294 // important to set it now so that calls to SetItemText() from
3295 // the event handler would change the text controls contents
3296 m_idEdited =
3297 event.m_item = info->item.hItem;
3298 event.m_label = info->item.pszText;
3299 event.m_editCancelled = false;
3300 }
3301 break;
3302
3303 case TVN_DELETEITEM:
3304 {
3305 eventType = wxEVT_COMMAND_TREE_DELETE_ITEM;
3306 NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
3307
3308 event.m_item = tv->itemOld.hItem;
3309
3310 if ( m_hasAnyAttr )
3311 {
3312 wxMapTreeAttr::iterator it = m_attrs.find(tv->itemOld.hItem);
3313 if ( it != m_attrs.end() )
3314 {
3315 delete it->second;
3316 m_attrs.erase(it);
3317 }
3318 }
3319 }
3320 break;
3321
3322 case TVN_ENDLABELEDIT:
3323 {
3324 eventType = wxEVT_COMMAND_TREE_END_LABEL_EDIT;
3325 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
3326
3327 event.m_item = info->item.hItem;
3328 event.m_label = info->item.pszText;
3329 event.m_editCancelled = info->item.pszText == NULL;
3330 break;
3331 }
3332
3333 #ifndef __WXWINCE__
3334 // These *must* not be removed or TVN_GETINFOTIP will
3335 // not be processed each time the mouse is moved
3336 // and the tooltip will only ever update once.
3337 case TTN_NEEDTEXTA:
3338 case TTN_NEEDTEXTW:
3339 {
3340 *result = 0;
3341
3342 break;
3343 }
3344
3345 #ifdef TVN_GETINFOTIP
3346 case TVN_GETINFOTIP:
3347 {
3348 eventType = wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP;
3349 NMTVGETINFOTIP *info = (NMTVGETINFOTIP*)lParam;
3350
3351 // Which item are we trying to get a tooltip for?
3352 event.m_item = info->hItem;
3353
3354 break;
3355 }
3356 #endif // TVN_GETINFOTIP
3357 #endif // !__WXWINCE__
3358
3359 case TVN_GETDISPINFO:
3360 eventType = wxEVT_COMMAND_TREE_GET_INFO;
3361 // fall through
3362
3363 case TVN_SETDISPINFO:
3364 {
3365 if ( eventType == wxEVT_NULL )
3366 eventType = wxEVT_COMMAND_TREE_SET_INFO;
3367 //else: get, already set above
3368
3369 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
3370
3371 event.m_item = info->item.hItem;
3372 break;
3373 }
3374
3375 case TVN_ITEMEXPANDING:
3376 case TVN_ITEMEXPANDED:
3377 {
3378 NM_TREEVIEW *tv = (NM_TREEVIEW*)lParam;
3379
3380 int what;
3381 switch ( tv->action )
3382 {
3383 default:
3384 wxLogDebug(wxT("unexpected code %d in TVN_ITEMEXPAND message"), tv->action);
3385 // fall through
3386
3387 case TVE_EXPAND:
3388 what = IDX_EXPAND;
3389 break;
3390
3391 case TVE_COLLAPSE:
3392 what = IDX_COLLAPSE;
3393 break;
3394 }
3395
3396 int how = hdr->code == TVN_ITEMEXPANDING ? IDX_DOING
3397 : IDX_DONE;
3398
3399 eventType = gs_expandEvents[what][how];
3400
3401 event.m_item = tv->itemNew.hItem;
3402 }
3403 break;
3404
3405 case TVN_KEYDOWN:
3406 {
3407 TV_KEYDOWN *info = (TV_KEYDOWN *)lParam;
3408
3409 // fabricate the lParam and wParam parameters sufficiently
3410 // similar to the ones from a "real" WM_KEYDOWN so that
3411 // CreateKeyEvent() works correctly
3412 return MSWHandleTreeKeyDownEvent(
3413 info->wVKey, (wxIsAltDown() ? KF_ALTDOWN : 0) << 16);
3414 }
3415
3416
3417 // Vista's tree control has introduced some problems with our
3418 // multi-selection tree. When TreeView_SelectItem() is called,
3419 // the wrong items are deselected.
3420
3421 // Fortunately, Vista provides a new notification, TVN_ITEMCHANGING
3422 // that can be used to regulate this incorrect behavior. The
3423 // following messages will allow only the unlocked item's selection
3424 // state to change
3425
3426 case TVN_ITEMCHANGINGA:
3427 case TVN_ITEMCHANGINGW:
3428 {
3429 // we only need to handles these in multi-select trees
3430 if ( HasFlag(wxTR_MULTIPLE) )
3431 {
3432 // get info about the item about to be changed
3433 NMTVITEMCHANGE* info = (NMTVITEMCHANGE*)lParam;
3434 if (TreeItemUnlocker::IsLocked(info->hItem))
3435 {
3436 // item's state is locked, don't allow the change
3437 // returning 1 will disallow the change
3438 *result = 1;
3439 return true;
3440 }
3441 }
3442
3443 // allow the state change
3444 }
3445 return false;
3446
3447 // NB: MSLU is broken and sends TVN_SELCHANGEDA instead of
3448 // TVN_SELCHANGEDW in Unicode mode under Win98. Therefore
3449 // we have to handle both messages:
3450 case TVN_SELCHANGEDA:
3451 case TVN_SELCHANGEDW:
3452 if ( !HasFlag(wxTR_MULTIPLE) || !m_changingSelection )
3453 {
3454 eventType = wxEVT_COMMAND_TREE_SEL_CHANGED;
3455 }
3456 // fall through
3457
3458 case TVN_SELCHANGINGA:
3459 case TVN_SELCHANGINGW:
3460 if ( !HasFlag(wxTR_MULTIPLE) || !m_changingSelection )
3461 {
3462 if ( eventType == wxEVT_NULL )
3463 eventType = wxEVT_COMMAND_TREE_SEL_CHANGING;
3464 //else: already set above
3465
3466 if (hdr->code == TVN_SELCHANGINGW ||
3467 hdr->code == TVN_SELCHANGEDW)
3468 {
3469 NM_TREEVIEWW *tv = (NM_TREEVIEWW *)lParam;
3470 event.m_item = tv->itemNew.hItem;
3471 event.m_itemOld = tv->itemOld.hItem;
3472 }
3473 else
3474 {
3475 NM_TREEVIEWA *tv = (NM_TREEVIEWA *)lParam;
3476 event.m_item = tv->itemNew.hItem;
3477 event.m_itemOld = tv->itemOld.hItem;
3478 }
3479 }
3480
3481 // we receive this message from WM_LBUTTONDOWN handler inside
3482 // comctl32.dll and so before the click is passed to
3483 // DefWindowProc() which sets the focus to the window which was
3484 // clicked and this can lead to unexpected event sequences: for
3485 // example, we may get a "selection change" event from the tree
3486 // before getting a "kill focus" event for the text control which
3487 // had the focus previously, thus breaking user code doing input
3488 // validation
3489 //
3490 // to avoid such surprises, we force the generation of focus events
3491 // now, before we generate the selection change ones
3492 SetFocus();
3493 break;
3494
3495 // instead of explicitly checking for _WIN32_IE, check if the
3496 // required symbols are available in the headers
3497 #if defined(CDDS_PREPAINT) && !wxUSE_COMCTL32_SAFELY
3498 case NM_CUSTOMDRAW:
3499 {
3500 LPNMTVCUSTOMDRAW lptvcd = (LPNMTVCUSTOMDRAW)lParam;
3501 NMCUSTOMDRAW& nmcd = lptvcd->nmcd;
3502 switch ( nmcd.dwDrawStage )
3503 {
3504 case CDDS_PREPAINT:
3505 // if we've got any items with non standard attributes,
3506 // notify us before painting each item
3507 *result = m_hasAnyAttr ? CDRF_NOTIFYITEMDRAW
3508 : CDRF_DODEFAULT;
3509
3510 // windows in TreeCtrl use one-based index for item state images,
3511 // 0 indexed image is not being used, we're using zero-based index,
3512 // so we have to add temp image (of zero index) to state image list
3513 // before we draw any item, then after items are drawn we have to
3514 // delete it (in POSTPAINT notify)
3515 if (m_imageListState && m_imageListState->GetImageCount() > 0)
3516 {
3517 typedef BOOL (wxSTDCALL *ImageList_Copy_t)
3518 (HIMAGELIST, int, HIMAGELIST, int, UINT);
3519 static ImageList_Copy_t s_pfnImageList_Copy = NULL;
3520 static bool loaded = false;
3521
3522 if ( !loaded )
3523 {
3524 wxLoadedDLL dllComCtl32(wxT("comctl32.dll"));
3525 if ( dllComCtl32.IsLoaded() )
3526 wxDL_INIT_FUNC(s_pfn, ImageList_Copy, dllComCtl32);
3527 }
3528
3529 if ( !s_pfnImageList_Copy )
3530 {
3531 // this code is broken with ImageList_Copy()
3532 // but I don't care enough about Win95 support
3533 // to write it now -- if anybody does, please
3534 // do it
3535 wxFAIL_MSG("TODO: implement this for Win95");
3536 break;
3537 }
3538
3539 const HIMAGELIST
3540 hImageList = GetHimagelistOf(m_imageListState);
3541
3542 // add temporary image
3543 int width, height;
3544 m_imageListState->GetSize(0, width, height);
3545
3546 HBITMAP hbmpTemp = ::CreateBitmap(width, height, 1, 1, NULL);
3547 int index = ::ImageList_Add(hImageList, hbmpTemp, hbmpTemp);
3548 ::DeleteObject(hbmpTemp);
3549
3550 if ( index != -1 )
3551 {
3552 // move images to right
3553 for ( int i = index; i > 0; i-- )
3554 {
3555 (*s_pfnImageList_Copy)(hImageList, i,
3556 hImageList, i-1,
3557 ILCF_MOVE);
3558 }
3559
3560 // we must remove the image in POSTPAINT notify
3561 *result |= CDRF_NOTIFYPOSTPAINT;
3562 }
3563 }
3564 break;
3565
3566 case CDDS_POSTPAINT:
3567 // we are deleting temp image of 0 index, which was
3568 // added before items were drawn (in PREPAINT notify)
3569 if (m_imageListState && m_imageListState->GetImageCount() > 0)
3570 m_imageListState->Remove(0);
3571 break;
3572
3573 case CDDS_ITEMPREPAINT:
3574 {
3575 wxMapTreeAttr::iterator
3576 it = m_attrs.find((void *)nmcd.dwItemSpec);
3577
3578 if ( it == m_attrs.end() )
3579 {
3580 // nothing to do for this item
3581 *result = CDRF_DODEFAULT;
3582 break;
3583 }
3584
3585 wxTreeItemAttr * const attr = it->second;
3586
3587 wxTreeViewItem tvItem((void *)nmcd.dwItemSpec,
3588 TVIF_STATE, TVIS_DROPHILITED);
3589 DoGetItem(&tvItem);
3590 const UINT tvItemState = tvItem.state;
3591
3592 // selection colours should override ours,
3593 // otherwise it is too confusing to the user
3594 if ( !(nmcd.uItemState & CDIS_SELECTED) &&
3595 !(tvItemState & TVIS_DROPHILITED) )
3596 {
3597 wxColour colBack;
3598 if ( attr->HasBackgroundColour() )
3599 {
3600 colBack = attr->GetBackgroundColour();
3601 lptvcd->clrTextBk = wxColourToRGB(colBack);
3602 }
3603 }
3604
3605 // but we still want to keep the special foreground
3606 // colour when we don't have focus (we can't keep
3607 // it when we do, it would usually be unreadable on
3608 // the almost inverted bg colour...)
3609 if ( ( !(nmcd.uItemState & CDIS_SELECTED) ||
3610 FindFocus() != this ) &&
3611 !(tvItemState & TVIS_DROPHILITED) )
3612 {
3613 wxColour colText;
3614 if ( attr->HasTextColour() )
3615 {
3616 colText = attr->GetTextColour();
3617 lptvcd->clrText = wxColourToRGB(colText);
3618 }
3619 }
3620
3621 if ( attr->HasFont() )
3622 {
3623 HFONT hFont = GetHfontOf(attr->GetFont());
3624
3625 ::SelectObject(nmcd.hdc, hFont);
3626
3627 *result = CDRF_NEWFONT;
3628 }
3629 else // no specific font
3630 {
3631 *result = CDRF_DODEFAULT;
3632 }
3633 }
3634 break;
3635
3636 default:
3637 *result = CDRF_DODEFAULT;
3638 }
3639 }
3640
3641 // we always process it
3642 return true;
3643 #endif // have owner drawn support in headers
3644
3645 case NM_CLICK:
3646 {
3647 DWORD pos = GetMessagePos();
3648 POINT point;
3649 point.x = LOWORD(pos);
3650 point.y = HIWORD(pos);
3651 ::MapWindowPoints(HWND_DESKTOP, GetHwnd(), &point, 1);
3652 int htFlags = 0;
3653 wxTreeItemId item = HitTest(wxPoint(point.x, point.y), htFlags);
3654
3655 if ( htFlags & wxTREE_HITTEST_ONITEMSTATEICON )
3656 {
3657 event.m_item = item;
3658 eventType = wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK;
3659 }
3660
3661 break;
3662 }
3663
3664 case NM_DBLCLK:
3665 case NM_RCLICK:
3666 {
3667 TV_HITTESTINFO tvhti;
3668 ::GetCursorPos(&tvhti.pt);
3669 ::ScreenToClient(GetHwnd(), &tvhti.pt);
3670 if ( TreeView_HitTest(GetHwnd(), &tvhti) )
3671 {
3672 if ( MSWIsOnItem(tvhti.flags) )
3673 {
3674 event.m_item = tvhti.hItem;
3675 eventType = (int)hdr->code == NM_DBLCLK
3676 ? wxEVT_COMMAND_TREE_ITEM_ACTIVATED
3677 : wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK;
3678
3679 event.m_pointDrag.x = tvhti.pt.x;
3680 event.m_pointDrag.y = tvhti.pt.y;
3681 }
3682
3683 break;
3684 }
3685 }
3686 // fall through
3687
3688 default:
3689 return wxControl::MSWOnNotify(idCtrl, lParam, result);
3690 }
3691
3692 event.SetEventType(eventType);
3693
3694 bool processed = HandleTreeEvent(event);
3695
3696 // post processing
3697 switch ( hdr->code )
3698 {
3699 case NM_DBLCLK:
3700 // we translate NM_DBLCLK into ACTIVATED event and if the user
3701 // handled the activation of the item we shouldn't proceed with
3702 // also using the same double click for toggling the item expanded
3703 // state -- but OTOH do let the user to expand/collapse the item by
3704 // double clicking on it if the activation is not handled specially
3705 *result = processed;
3706 break;
3707
3708 case NM_RCLICK:
3709 // prevent tree control from sending WM_CONTEXTMENU to our parent
3710 // (which it does if NM_RCLICK is not handled) because we want to
3711 // send it to the control itself
3712 *result =
3713 processed = true;
3714
3715 ::SendMessage(GetHwnd(), WM_CONTEXTMENU,
3716 (WPARAM)GetHwnd(), ::GetMessagePos());
3717 break;
3718
3719 case TVN_BEGINDRAG:
3720 case TVN_BEGINRDRAG:
3721 #if wxUSE_DRAGIMAGE
3722 if ( event.IsAllowed() )
3723 {
3724 // normally this is impossible because the m_dragImage is
3725 // deleted once the drag operation is over
3726 wxASSERT_MSG( !m_dragImage, wxT("starting to drag once again?") );
3727
3728 m_dragImage = new wxDragImage(*this, event.m_item);
3729 m_dragImage->BeginDrag(wxPoint(0,0), this);
3730 m_dragImage->Show();
3731
3732 m_dragStarted = true;
3733 }
3734 #endif // wxUSE_DRAGIMAGE
3735 break;
3736
3737 case TVN_DELETEITEM:
3738 {
3739 // NB: we might process this message using wxWidgets event
3740 // tables, but due to overhead of wxWin event system we
3741 // prefer to do it here ourself (otherwise deleting a tree
3742 // with many items is just too slow)
3743 NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
3744
3745 wxTreeItemParam *param =
3746 (wxTreeItemParam *)tv->itemOld.lParam;
3747 delete param;
3748
3749 processed = true; // Make sure we don't get called twice
3750 }
3751 break;
3752
3753 case TVN_BEGINLABELEDIT:
3754 // return true to cancel label editing
3755 *result = !event.IsAllowed();
3756
3757 // set ES_WANTRETURN ( like we do in BeginLabelEdit )
3758 if ( event.IsAllowed() )
3759 {
3760 HWND hText = TreeView_GetEditControl(GetHwnd());
3761 if ( hText )
3762 {
3763 // MBN: if m_textCtrl already has an HWND, it is a stale
3764 // pointer from a previous edit (because the user
3765 // didn't modify the label before dismissing the control,
3766 // and TVN_ENDLABELEDIT was not sent), so delete it
3767 if ( m_textCtrl && m_textCtrl->GetHWND() )
3768 DeleteTextCtrl();
3769 if ( !m_textCtrl )
3770 m_textCtrl = new wxTextCtrl();
3771 m_textCtrl->SetParent(this);
3772 m_textCtrl->SetHWND((WXHWND)hText);
3773 m_textCtrl->SubclassWin((WXHWND)hText);
3774
3775 // set wxTE_PROCESS_ENTER style for the text control to
3776 // force it to process the Enter presses itself, otherwise
3777 // they could be stolen from it by the dialog
3778 // navigation code
3779 m_textCtrl->SetWindowStyle(m_textCtrl->GetWindowStyle()
3780 | wxTE_PROCESS_ENTER);
3781 }
3782 }
3783 else // we had set m_idEdited before
3784 {
3785 m_idEdited.Unset();
3786 }
3787 break;
3788
3789 case TVN_ENDLABELEDIT:
3790 // return true to set the label to the new string: note that we
3791 // also must pretend that we did process the message or it is going
3792 // to be passed to DefWindowProc() which will happily return false
3793 // cancelling the label change
3794 *result = event.IsAllowed();
3795 processed = true;
3796
3797 // ensure that we don't have the text ctrl which is going to be
3798 // deleted any more
3799 DeleteTextCtrl();
3800 break;
3801
3802 #ifndef __WXWINCE__
3803 #ifdef TVN_GETINFOTIP
3804 case TVN_GETINFOTIP:
3805 {
3806 // If the user permitted a tooltip change, change it
3807 if (event.IsAllowed())
3808 {
3809 SetToolTip(event.m_label);
3810 }
3811 }
3812 break;
3813 #endif
3814 #endif
3815
3816 case TVN_SELCHANGING:
3817 case TVN_ITEMEXPANDING:
3818 // return true to prevent the action from happening
3819 *result = !event.IsAllowed();
3820 break;
3821
3822 case TVN_ITEMEXPANDED:
3823 {
3824 NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
3825 const wxTreeItemId id(tv->itemNew.hItem);
3826
3827 if ( tv->action == TVE_COLLAPSE )
3828 {
3829 if ( wxApp::GetComCtl32Version() >= 600 )
3830 {
3831 // for some reason the item selection rectangle depends
3832 // on whether it is expanded or collapsed (at least
3833 // with comctl32.dll v6): it is wider (by 3 pixels) in
3834 // the expanded state, so when the item collapses and
3835 // then is deselected the rightmost 3 pixels of the
3836 // previously drawn selection are left on the screen
3837 //
3838 // it's not clear if it's a bug in comctl32.dll or in
3839 // our code (because it does not happen in Explorer but
3840 // OTOH we don't do anything which could result in this
3841 // AFAICS) but we do need to work around it to avoid
3842 // ugly artifacts
3843 RefreshItem(id);
3844 }
3845 }
3846 else // expand
3847 {
3848 // the item is also not refreshed properly after expansion when
3849 // it has an image depending on the expanded/collapsed state:
3850 // again, it's not clear if the bug is in comctl32.dll or our
3851 // code...
3852 int image = GetItemImage(id, wxTreeItemIcon_Expanded);
3853 if ( image != -1 )
3854 {
3855 RefreshItem(id);
3856 }
3857 }
3858 }
3859 break;
3860
3861 case TVN_GETDISPINFO:
3862 // NB: so far the user can't set the image himself anyhow, so do it
3863 // anyway - but this may change later
3864 //if ( /* !processed && */ )
3865 {
3866 wxTreeItemId item = event.m_item;
3867 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
3868
3869 const wxTreeItemParam * const param = GetItemParam(item);
3870 if ( !param )
3871 break;
3872
3873 if ( info->item.mask & TVIF_IMAGE )
3874 {
3875 info->item.iImage =
3876 param->GetImage
3877 (
3878 IsExpanded(item) ? wxTreeItemIcon_Expanded
3879 : wxTreeItemIcon_Normal
3880 );
3881 }
3882 if ( info->item.mask & TVIF_SELECTEDIMAGE )
3883 {
3884 info->item.iSelectedImage =
3885 param->GetImage
3886 (
3887 IsExpanded(item) ? wxTreeItemIcon_SelectedExpanded
3888 : wxTreeItemIcon_Selected
3889 );
3890 }
3891 }
3892 break;
3893
3894 //default:
3895 // for the other messages the return value is ignored and there is
3896 // nothing special to do
3897 }
3898 return processed;
3899 }
3900
3901 // ----------------------------------------------------------------------------
3902 // State control.
3903 // ----------------------------------------------------------------------------
3904
3905 // why do they define INDEXTOSTATEIMAGEMASK but not the inverse?
3906 #define STATEIMAGEMASKTOINDEX(state) (((state) & TVIS_STATEIMAGEMASK) >> 12)
3907
3908 int wxTreeCtrl::DoGetItemState(const wxTreeItemId& item) const
3909 {
3910 wxCHECK_MSG( item.IsOk(), wxTREE_ITEMSTATE_NONE, wxT("invalid tree item") );
3911
3912 // receive the desired information
3913 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_STATEIMAGEMASK);
3914 DoGetItem(&tvItem);
3915
3916 // state images are one-based
3917 return STATEIMAGEMASKTOINDEX(tvItem.state) - 1;
3918 }
3919
3920 void wxTreeCtrl::DoSetItemState(const wxTreeItemId& item, int state)
3921 {
3922 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
3923
3924 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_STATEIMAGEMASK);
3925
3926 // state images are one-based
3927 // 0 if no state image display (wxTREE_ITEMSTATE_NONE = -1)
3928 tvItem.state = INDEXTOSTATEIMAGEMASK(state + 1);
3929
3930 DoSetItem(&tvItem);
3931 }
3932
3933 #endif // wxUSE_TREECTRL