1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/treectrl.cpp
4 // Author: Julian Smart
5 // Modified by: Vadim Zeitlin to be less MSW-specific on 10.10.98
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
21 #pragma implementation "treectrl.h"
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
33 #include "wx/msw/private.h"
35 // Set this to 1 to be _absolutely_ sure that repainting will work for all
36 // comctl32.dll versions
37 #define wxUSE_COMCTL32_SAFELY 0
41 #include "wx/dynarray.h"
42 #include "wx/imaglist.h"
43 #include "wx/settings.h"
44 #include "wx/msw/treectrl.h"
45 #include "wx/msw/dragimag.h"
47 // include <commctrl.h> "properly"
48 #include "wx/msw/wrapcctl.h"
50 // macros to hide the cast ugliness
51 // --------------------------------
53 // ptr is the real item id, i.e. wxTreeItemId::m_pItem
54 #define HITEM_PTR(ptr) (HTREEITEM)(ptr)
56 // item here is a wxTreeItemId
57 #define HITEM(item) HITEM_PTR((item).m_pItem)
59 // the native control doesn't support multiple selections under MSW and we
60 // have 2 ways to emulate them: either using TVS_CHECKBOXES style and let
61 // checkboxes be the selection status (checked == selected) or by really
62 // emulating everything, i.e. intercepting mouse and key events &c. The first
63 // approach is much easier but doesn't work with comctl32.dll < 4.71 and also
65 #define wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE 0
67 // ----------------------------------------------------------------------------
69 // ----------------------------------------------------------------------------
71 // wrapper for TreeView_HitTest
72 static HTREEITEM
GetItemFromPoint(HWND hwndTV
, int x
, int y
)
78 return (HTREEITEM
)TreeView_HitTest(hwndTV
, &tvht
);
81 #if !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
83 // wrappers for TreeView_GetItem/TreeView_SetItem
84 static bool IsItemSelected(HWND hwndTV
, HTREEITEM hItem
)
88 tvi
.mask
= TVIF_STATE
| TVIF_HANDLE
;
89 tvi
.stateMask
= TVIS_SELECTED
;
92 if ( !TreeView_GetItem(hwndTV
, &tvi
) )
94 wxLogLastError(wxT("TreeView_GetItem"));
97 return (tvi
.state
& TVIS_SELECTED
) != 0;
100 static bool SelectItem(HWND hwndTV
, HTREEITEM hItem
, bool select
= true)
103 tvi
.mask
= TVIF_STATE
| TVIF_HANDLE
;
104 tvi
.stateMask
= TVIS_SELECTED
;
105 tvi
.state
= select
? TVIS_SELECTED
: 0;
108 if ( TreeView_SetItem(hwndTV
, &tvi
) == -1 )
110 wxLogLastError(wxT("TreeView_SetItem"));
117 static inline void UnselectItem(HWND hwndTV
, HTREEITEM htItem
)
119 SelectItem(hwndTV
, htItem
, false);
122 static inline void ToggleItemSelection(HWND hwndTV
, HTREEITEM htItem
)
124 SelectItem(hwndTV
, htItem
, !IsItemSelected(hwndTV
, htItem
));
127 // helper function which selects all items in a range and, optionally,
128 // unselects all others
129 static void SelectRange(HWND hwndTV
,
132 bool unselectOthers
= true)
134 // find the first (or last) item and select it
136 HTREEITEM htItem
= (HTREEITEM
)TreeView_GetRoot(hwndTV
);
137 while ( htItem
&& cont
)
139 if ( (htItem
== htFirst
) || (htItem
== htLast
) )
141 if ( !IsItemSelected(hwndTV
, htItem
) )
143 SelectItem(hwndTV
, htItem
);
150 if ( unselectOthers
&& IsItemSelected(hwndTV
, htItem
) )
152 UnselectItem(hwndTV
, htItem
);
156 htItem
= (HTREEITEM
)TreeView_GetNextVisible(hwndTV
, htItem
);
159 // select the items in range
160 cont
= htFirst
!= htLast
;
161 while ( htItem
&& cont
)
163 if ( !IsItemSelected(hwndTV
, htItem
) )
165 SelectItem(hwndTV
, htItem
);
168 cont
= (htItem
!= htFirst
) && (htItem
!= htLast
);
170 htItem
= (HTREEITEM
)TreeView_GetNextVisible(hwndTV
, htItem
);
174 if ( unselectOthers
)
178 if ( IsItemSelected(hwndTV
, htItem
) )
180 UnselectItem(hwndTV
, htItem
);
183 htItem
= (HTREEITEM
)TreeView_GetNextVisible(hwndTV
, htItem
);
187 // seems to be necessary - otherwise the just selected items don't always
188 // appear as selected
189 UpdateWindow(hwndTV
);
192 // helper function which tricks the standard control into changing the focused
193 // item without changing anything else (if someone knows why Microsoft doesn't
194 // allow to do it by just setting TVIS_FOCUSED flag, please tell me!)
195 static void SetFocus(HWND hwndTV
, HTREEITEM htItem
)
198 HTREEITEM htFocus
= (HTREEITEM
)TreeView_GetSelection(hwndTV
);
203 if ( htItem
!= htFocus
)
205 // remember the selection state of the item
206 bool wasSelected
= IsItemSelected(hwndTV
, htItem
);
208 if ( htFocus
&& IsItemSelected(hwndTV
, htFocus
) )
210 // prevent the tree from unselecting the old focus which it
211 // would do by default (TreeView_SelectItem unselects the
213 TreeView_SelectItem(hwndTV
, 0);
214 SelectItem(hwndTV
, htFocus
);
217 TreeView_SelectItem(hwndTV
, htItem
);
221 // need to clear the selection which TreeView_SelectItem() gave
223 UnselectItem(hwndTV
, htItem
);
225 //else: was selected, still selected - ok
227 //else: nothing to do, focus already there
233 bool wasFocusSelected
= IsItemSelected(hwndTV
, htFocus
);
235 // just clear the focus
236 TreeView_SelectItem(hwndTV
, 0);
238 if ( wasFocusSelected
)
240 // restore the selection state
241 SelectItem(hwndTV
, htFocus
);
244 //else: nothing to do, no focus already
248 #endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
250 // ----------------------------------------------------------------------------
252 // ----------------------------------------------------------------------------
254 // a convenient wrapper around TV_ITEM struct which adds a ctor
256 #pragma warning( disable : 4097 ) // inheriting from typedef
259 struct wxTreeViewItem
: public TV_ITEM
261 wxTreeViewItem(const wxTreeItemId
& item
, // the item handle
262 UINT mask_
, // fields which are valid
263 UINT stateMask_
= 0) // for TVIF_STATE only
267 // hItem member is always valid
268 mask
= mask_
| TVIF_HANDLE
;
269 stateMask
= stateMask_
;
274 // wxVirutalNode is used in place of a single root when 'hidden' root is
276 class wxVirtualNode
: public wxTreeViewItem
279 wxVirtualNode(wxTreeItemData
*data
)
280 : wxTreeViewItem(TVI_ROOT
, 0)
290 wxTreeItemData
*GetData() const { return m_data
; }
291 void SetData(wxTreeItemData
*data
) { delete m_data
; m_data
= data
; }
294 wxTreeItemData
*m_data
;
296 DECLARE_NO_COPY_CLASS(wxVirtualNode
)
300 #pragma warning( default : 4097 )
303 // a macro to get the virtual root, returns NULL if none
304 #define GET_VIRTUAL_ROOT() ((wxVirtualNode *)m_pVirtualRoot)
306 // returns true if the item is the virtual root
307 #define IS_VIRTUAL_ROOT(item) (HITEM(item) == TVI_ROOT)
309 // a class which encapsulates the tree traversal logic: it vists all (unless
310 // OnVisit() returns false) items under the given one
311 class wxTreeTraversal
314 wxTreeTraversal(const wxTreeCtrl
*tree
)
319 // do traverse the tree: visit all items (recursively by default) under the
320 // given one; return true if all items were traversed or false if the
321 // traversal was aborted because OnVisit returned false
322 bool DoTraverse(const wxTreeItemId
& root
, bool recursively
= true);
324 // override this function to do whatever is needed for each item, return
325 // false to stop traversing
326 virtual bool OnVisit(const wxTreeItemId
& item
) = 0;
329 const wxTreeCtrl
*GetTree() const { return m_tree
; }
332 bool Traverse(const wxTreeItemId
& root
, bool recursively
);
334 const wxTreeCtrl
*m_tree
;
336 DECLARE_NO_COPY_CLASS(wxTreeTraversal
)
339 // internal class for getting the selected items
340 class TraverseSelections
: public wxTreeTraversal
343 TraverseSelections(const wxTreeCtrl
*tree
,
344 wxArrayTreeItemIds
& selections
)
345 : wxTreeTraversal(tree
), m_selections(selections
)
347 m_selections
.Empty();
349 DoTraverse(tree
->GetRootItem());
352 virtual bool OnVisit(const wxTreeItemId
& item
)
354 // can't visit a virtual node.
355 if ( (GetTree()->GetRootItem() == item
) && (GetTree()->GetWindowStyle() & wxTR_HIDE_ROOT
))
360 #if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
361 if ( GetTree()->IsItemChecked(item
) )
363 if ( ::IsItemSelected(GetHwndOf(GetTree()), HITEM(item
)) )
366 m_selections
.Add(item
);
372 size_t GetCount() const { return m_selections
.GetCount(); }
375 wxArrayTreeItemIds
& m_selections
;
377 DECLARE_NO_COPY_CLASS(TraverseSelections
)
380 // internal class for counting tree items
381 class TraverseCounter
: public wxTreeTraversal
384 TraverseCounter(const wxTreeCtrl
*tree
,
385 const wxTreeItemId
& root
,
387 : wxTreeTraversal(tree
)
391 DoTraverse(root
, recursively
);
394 virtual bool OnVisit(const wxTreeItemId
& WXUNUSED(item
))
401 size_t GetCount() const { return m_count
; }
406 DECLARE_NO_COPY_CLASS(TraverseCounter
)
409 // ----------------------------------------------------------------------------
410 // This class is needed for support of different images: the Win32 common
411 // control natively supports only 2 images (the normal one and another for the
412 // selected state). We wish to provide support for 2 more of them for folder
413 // items (i.e. those which have children): for expanded state and for expanded
414 // selected state. For this we use this structure to store the additional items
417 // There is only one problem with this: when we retrieve the item's data, we
418 // don't know whether we get a pointer to wxTreeItemData or
419 // wxTreeItemIndirectData. So we always set the item id to an invalid value
420 // in this class and the code using the client data checks for it and retrieves
421 // the real client data in this case.
422 // ----------------------------------------------------------------------------
424 class wxTreeItemIndirectData
: public wxTreeItemData
427 // ctor associates this data with the item and the real item data becomes
428 // available through our GetData() method
429 wxTreeItemIndirectData(wxTreeCtrl
*tree
, const wxTreeItemId
& item
)
431 for ( size_t n
= 0; n
< WXSIZEOF(m_images
); n
++ )
437 m_data
= tree
->GetItemData(item
);
439 // and set ourselves as the new one
440 tree
->SetIndirectItemData(item
, this);
442 // we must have the invalid value for the item
446 // dtor deletes the associated data as well
447 virtual ~wxTreeItemIndirectData() { delete m_data
; }
450 // get the real data associated with the item
451 wxTreeItemData
*GetData() const { return m_data
; }
453 void SetData(wxTreeItemData
*data
) { m_data
= data
; }
455 // do we have such image?
456 bool HasImage(wxTreeItemIcon which
) const { return m_images
[which
] != -1; }
458 int GetImage(wxTreeItemIcon which
) const { return m_images
[which
]; }
460 void SetImage(int image
, wxTreeItemIcon which
) { m_images
[which
] = image
; }
463 // all the images associated with the item
464 int m_images
[wxTreeItemIcon_Max
];
466 // the real client data
467 wxTreeItemData
*m_data
;
469 DECLARE_NO_COPY_CLASS(wxTreeItemIndirectData
)
472 // ----------------------------------------------------------------------------
474 // ----------------------------------------------------------------------------
476 #if wxUSE_EXTENDED_RTTI
477 WX_DEFINE_FLAGS( wxTreeCtrlStyle
)
479 wxBEGIN_FLAGS( wxTreeCtrlStyle
)
480 // new style border flags, we put them first to
481 // use them for streaming out
482 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
483 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
484 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
485 wxFLAGS_MEMBER(wxBORDER_RAISED
)
486 wxFLAGS_MEMBER(wxBORDER_STATIC
)
487 wxFLAGS_MEMBER(wxBORDER_NONE
)
489 // old style border flags
490 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
491 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
492 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
493 wxFLAGS_MEMBER(wxRAISED_BORDER
)
494 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
495 wxFLAGS_MEMBER(wxBORDER
)
497 // standard window styles
498 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
499 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
500 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
501 wxFLAGS_MEMBER(wxWANTS_CHARS
)
502 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
503 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
504 wxFLAGS_MEMBER(wxVSCROLL
)
505 wxFLAGS_MEMBER(wxHSCROLL
)
507 wxFLAGS_MEMBER(wxTR_EDIT_LABELS
)
508 wxFLAGS_MEMBER(wxTR_NO_BUTTONS
)
509 wxFLAGS_MEMBER(wxTR_HAS_BUTTONS
)
510 wxFLAGS_MEMBER(wxTR_TWIST_BUTTONS
)
511 wxFLAGS_MEMBER(wxTR_NO_LINES
)
512 wxFLAGS_MEMBER(wxTR_FULL_ROW_HIGHLIGHT
)
513 wxFLAGS_MEMBER(wxTR_LINES_AT_ROOT
)
514 wxFLAGS_MEMBER(wxTR_HIDE_ROOT
)
515 wxFLAGS_MEMBER(wxTR_ROW_LINES
)
516 wxFLAGS_MEMBER(wxTR_HAS_VARIABLE_ROW_HEIGHT
)
517 wxFLAGS_MEMBER(wxTR_SINGLE
)
518 wxFLAGS_MEMBER(wxTR_MULTIPLE
)
519 wxFLAGS_MEMBER(wxTR_EXTENDED
)
520 wxFLAGS_MEMBER(wxTR_DEFAULT_STYLE
)
522 wxEND_FLAGS( wxTreeCtrlStyle
)
524 IMPLEMENT_DYNAMIC_CLASS_XTI(wxTreeCtrl
, wxControl
,"wx/treectrl.h")
526 wxBEGIN_PROPERTIES_TABLE(wxTreeCtrl
)
527 wxEVENT_PROPERTY( TextUpdated
, wxEVT_COMMAND_TEXT_UPDATED
, wxCommandEvent
)
528 wxEVENT_RANGE_PROPERTY( TreeEvent
, wxEVT_COMMAND_TREE_BEGIN_DRAG
, wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK
, wxTreeEvent
)
529 wxPROPERTY_FLAGS( WindowStyle
, wxTreeCtrlStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
530 wxEND_PROPERTIES_TABLE()
532 wxBEGIN_HANDLERS_TABLE(wxTreeCtrl
)
533 wxEND_HANDLERS_TABLE()
535 wxCONSTRUCTOR_5( wxTreeCtrl
, wxWindow
* , Parent
, wxWindowID
, Id
, wxPoint
, Position
, wxSize
, Size
, long , WindowStyle
)
537 IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl
, wxControl
)
540 // ----------------------------------------------------------------------------
542 // ----------------------------------------------------------------------------
544 // indices in gs_expandEvents table below
559 // handy table for sending events - it has to be initialized during run-time
560 // now so can't be const any more
561 static /* const */ wxEventType gs_expandEvents
[IDX_WHAT_MAX
][IDX_HOW_MAX
];
564 but logically it's a const table with the following entries:
567 { wxEVT_COMMAND_TREE_ITEM_COLLAPSED, wxEVT_COMMAND_TREE_ITEM_COLLAPSING },
568 { wxEVT_COMMAND_TREE_ITEM_EXPANDED, wxEVT_COMMAND_TREE_ITEM_EXPANDING }
572 // ============================================================================
574 // ============================================================================
576 // ----------------------------------------------------------------------------
578 // ----------------------------------------------------------------------------
580 bool wxTreeTraversal::DoTraverse(const wxTreeItemId
& root
, bool recursively
)
582 if ( !OnVisit(root
) )
585 return Traverse(root
, recursively
);
588 bool wxTreeTraversal::Traverse(const wxTreeItemId
& root
, bool recursively
)
590 wxTreeItemIdValue cookie
;
591 wxTreeItemId child
= m_tree
->GetFirstChild(root
, cookie
);
592 while ( child
.IsOk() )
594 // depth first traversal
595 if ( recursively
&& !Traverse(child
, true) )
598 if ( !OnVisit(child
) )
601 child
= m_tree
->GetNextChild(root
, cookie
);
607 // ----------------------------------------------------------------------------
608 // construction and destruction
609 // ----------------------------------------------------------------------------
611 void wxTreeCtrl::Init()
613 m_imageListNormal
= NULL
;
614 m_imageListState
= NULL
;
615 m_ownsImageListNormal
= m_ownsImageListState
= false;
617 m_hasAnyAttr
= false;
619 m_pVirtualRoot
= NULL
;
621 // initialize the global array of events now as it can't be done statically
622 // with the wxEVT_XXX values being allocated during run-time only
623 gs_expandEvents
[IDX_COLLAPSE
][IDX_DONE
] = wxEVT_COMMAND_TREE_ITEM_COLLAPSED
;
624 gs_expandEvents
[IDX_COLLAPSE
][IDX_DOING
] = wxEVT_COMMAND_TREE_ITEM_COLLAPSING
;
625 gs_expandEvents
[IDX_EXPAND
][IDX_DONE
] = wxEVT_COMMAND_TREE_ITEM_EXPANDED
;
626 gs_expandEvents
[IDX_EXPAND
][IDX_DOING
] = wxEVT_COMMAND_TREE_ITEM_EXPANDING
;
629 bool wxTreeCtrl::Create(wxWindow
*parent
,
634 const wxValidator
& validator
,
635 const wxString
& name
)
639 if ( (style
& wxBORDER_MASK
) == wxBORDER_DEFAULT
)
640 style
|= wxBORDER_SUNKEN
;
642 if ( !CreateControl(parent
, id
, pos
, size
, style
, validator
, name
) )
646 DWORD wstyle
= MSWGetStyle(m_windowStyle
, & exStyle
);
647 wstyle
|= WS_TABSTOP
| TVS_SHOWSELALWAYS
;
649 if ((m_windowStyle
& wxTR_NO_LINES
) == 0)
650 wstyle
|= TVS_HASLINES
;
651 if ( m_windowStyle
& wxTR_HAS_BUTTONS
)
652 wstyle
|= TVS_HASBUTTONS
;
654 if ( m_windowStyle
& wxTR_EDIT_LABELS
)
655 wstyle
|= TVS_EDITLABELS
;
657 if ( m_windowStyle
& wxTR_LINES_AT_ROOT
)
658 wstyle
|= TVS_LINESATROOT
;
660 if ( m_windowStyle
& wxTR_FULL_ROW_HIGHLIGHT
)
662 if ( wxTheApp
->GetComCtl32Version() >= 471 )
663 wstyle
|= TVS_FULLROWSELECT
;
666 // using TVS_CHECKBOXES for emulation of a multiselection tree control
667 // doesn't work without the new enough headers
668 #if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE && \
669 !defined( __GNUWIN32_OLD__ ) && \
670 !defined( __BORLANDC__ ) && \
671 !defined( __WATCOMC__ ) && \
672 (!defined(__VISUALC__) || (__VISUALC__ > 1010))
674 // we emulate the multiple selection tree controls by using checkboxes: set
675 // up the image list we need for this if we do have multiple selections
676 if ( m_windowStyle
& wxTR_MULTIPLE
)
677 wstyle
|= TVS_CHECKBOXES
;
678 #endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
681 // Need so that TVN_GETINFOTIP messages will be sent
682 wstyle
|= TVS_INFOTIP
;
685 // Create the tree control.
686 if ( !MSWCreateControl(WC_TREEVIEW
, wstyle
, pos
, size
) )
689 #if wxUSE_COMCTL32_SAFELY
690 wxWindow::SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW
));
691 wxWindow::SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
693 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW
));
694 SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
696 // This works around a bug in the Windows tree control whereby for some versions
697 // of comctrl32, setting any colour actually draws the background in black.
698 // This will initialise the background to the system colour.
699 // THIS FIX NOW REVERTED since it caused problems on _other_ systems.
700 // Assume the user has an updated comctl32.dll.
701 ::SendMessage(GetHwnd(), TVM_SETBKCOLOR
, 0,-1);
702 wxWindow::SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW
));
703 SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
707 // VZ: this is some experimental code which may be used to get the
708 // TVS_CHECKBOXES style functionality for comctl32.dll < 4.71.
709 // AFAIK, the standard DLL does about the same thing anyhow.
711 if ( m_windowStyle
& wxTR_MULTIPLE
)
715 // create the DC compatible with the current screen
716 HDC hdcMem
= CreateCompatibleDC(NULL
);
718 // create a mono bitmap of the standard size
719 int x
= ::GetSystemMetrics(SM_CXMENUCHECK
);
720 int y
= ::GetSystemMetrics(SM_CYMENUCHECK
);
721 wxImageList
imagelistCheckboxes(x
, y
, false, 2);
722 HBITMAP hbmpCheck
= CreateBitmap(x
, y
, // bitmap size
723 1, // # of color planes
724 1, // # bits needed for one pixel
725 0); // array containing colour data
726 SelectObject(hdcMem
, hbmpCheck
);
728 // then draw a check mark into it
729 RECT rect
= { 0, 0, x
, y
};
730 if ( !::DrawFrameControl(hdcMem
, &rect
,
732 DFCS_BUTTONCHECK
| DFCS_CHECKED
) )
734 wxLogLastError(wxT("DrawFrameControl(check)"));
737 bmp
.SetHBITMAP((WXHBITMAP
)hbmpCheck
);
738 imagelistCheckboxes
.Add(bmp
);
740 if ( !::DrawFrameControl(hdcMem
, &rect
,
744 wxLogLastError(wxT("DrawFrameControl(uncheck)"));
747 bmp
.SetHBITMAP((WXHBITMAP
)hbmpCheck
);
748 imagelistCheckboxes
.Add(bmp
);
754 SetStateImageList(&imagelistCheckboxes
);
758 wxSetCCUnicodeFormat(GetHwnd());
763 wxTreeCtrl::~wxTreeCtrl()
765 // delete any attributes
768 WX_CLEAR_HASH_MAP(wxMapTreeAttr
, m_attrs
);
770 // prevent TVN_DELETEITEM handler from deleting the attributes again!
771 m_hasAnyAttr
= false;
776 // delete user data to prevent memory leaks
777 // also deletes hidden root node storage.
780 if (m_ownsImageListNormal
) delete m_imageListNormal
;
781 if (m_ownsImageListState
) delete m_imageListState
;
784 // ----------------------------------------------------------------------------
786 // ----------------------------------------------------------------------------
788 /* static */ wxVisualAttributes
789 wxTreeCtrl::GetClassDefaultAttributes(wxWindowVariant variant
)
791 wxVisualAttributes attrs
= GetCompositeControlsDefaultAttributes(variant
);
793 // common controls have their own default font
794 attrs
.font
= wxGetCCDefaultFont();
800 // simple wrappers which add error checking in debug mode
802 bool wxTreeCtrl::DoGetItem(wxTreeViewItem
* tvItem
) const
804 wxCHECK_MSG( tvItem
->hItem
!= TVI_ROOT
, false,
805 _T("can't retrieve virtual root item") );
807 if ( !TreeView_GetItem(GetHwnd(), tvItem
) )
809 wxLogLastError(wxT("TreeView_GetItem"));
817 void wxTreeCtrl::DoSetItem(wxTreeViewItem
* tvItem
)
819 if ( TreeView_SetItem(GetHwnd(), tvItem
) == -1 )
821 wxLogLastError(wxT("TreeView_SetItem"));
825 size_t wxTreeCtrl::GetCount() const
827 return (size_t)TreeView_GetCount(GetHwnd());
830 unsigned int wxTreeCtrl::GetIndent() const
832 return TreeView_GetIndent(GetHwnd());
835 void wxTreeCtrl::SetIndent(unsigned int indent
)
837 TreeView_SetIndent(GetHwnd(), indent
);
840 wxImageList
*wxTreeCtrl::GetImageList() const
842 return m_imageListNormal
;
845 wxImageList
*wxTreeCtrl::GetStateImageList() const
847 return m_imageListState
;
850 void wxTreeCtrl::SetAnyImageList(wxImageList
*imageList
, int which
)
853 TreeView_SetImageList(GetHwnd(),
854 imageList
? imageList
->GetHIMAGELIST() : 0,
858 void wxTreeCtrl::SetImageList(wxImageList
*imageList
)
860 if (m_ownsImageListNormal
)
861 delete m_imageListNormal
;
863 SetAnyImageList(m_imageListNormal
= imageList
, TVSIL_NORMAL
);
864 m_ownsImageListNormal
= false;
867 void wxTreeCtrl::SetStateImageList(wxImageList
*imageList
)
869 if (m_ownsImageListState
) delete m_imageListState
;
870 SetAnyImageList(m_imageListState
= imageList
, TVSIL_STATE
);
871 m_ownsImageListState
= false;
874 void wxTreeCtrl::AssignImageList(wxImageList
*imageList
)
876 SetImageList(imageList
);
877 m_ownsImageListNormal
= true;
880 void wxTreeCtrl::AssignStateImageList(wxImageList
*imageList
)
882 SetStateImageList(imageList
);
883 m_ownsImageListState
= true;
886 size_t wxTreeCtrl::GetChildrenCount(const wxTreeItemId
& item
,
887 bool recursively
) const
889 wxCHECK_MSG( item
.IsOk(), 0u, wxT("invalid tree item") );
891 TraverseCounter
counter(this, item
, recursively
);
892 return counter
.GetCount() - 1;
895 // ----------------------------------------------------------------------------
897 // ----------------------------------------------------------------------------
899 bool wxTreeCtrl::SetBackgroundColour(const wxColour
&colour
)
901 #if !wxUSE_COMCTL32_SAFELY
902 if ( !wxWindowBase::SetBackgroundColour(colour
) )
905 ::SendMessage(GetHwnd(), TVM_SETBKCOLOR
, 0, colour
.GetPixel());
911 bool wxTreeCtrl::SetForegroundColour(const wxColour
&colour
)
913 #if !wxUSE_COMCTL32_SAFELY
914 if ( !wxWindowBase::SetForegroundColour(colour
) )
917 ::SendMessage(GetHwnd(), TVM_SETTEXTCOLOR
, 0, colour
.GetPixel());
923 // ----------------------------------------------------------------------------
925 // ----------------------------------------------------------------------------
927 wxString
wxTreeCtrl::GetItemText(const wxTreeItemId
& item
) const
929 wxCHECK_MSG( item
.IsOk(), wxT(""), wxT("invalid tree item") );
931 wxChar buf
[512]; // the size is arbitrary...
933 wxTreeViewItem
tvItem(item
, TVIF_TEXT
);
934 tvItem
.pszText
= buf
;
935 tvItem
.cchTextMax
= WXSIZEOF(buf
);
936 if ( !DoGetItem(&tvItem
) )
938 // don't return some garbage which was on stack, but an empty string
942 return wxString(buf
);
945 void wxTreeCtrl::SetItemText(const wxTreeItemId
& item
, const wxString
& text
)
947 wxCHECK_RET( item
.IsOk(), wxT("invalid tree item") );
949 if ( IS_VIRTUAL_ROOT(item
) )
952 wxTreeViewItem
tvItem(item
, TVIF_TEXT
);
953 tvItem
.pszText
= (wxChar
*)text
.c_str(); // conversion is ok
956 // when setting the text of the item being edited, the text control should
957 // be updated to reflect the new text as well, otherwise calling
958 // SetItemText() in the OnBeginLabelEdit() handler doesn't have any effect
960 // don't use GetEditControl() here because m_textCtrl is not set yet
961 HWND hwndEdit
= TreeView_GetEditControl(GetHwnd());
964 if ( item
== m_idEdited
)
966 ::SetWindowText(hwndEdit
, text
);
971 int wxTreeCtrl::DoGetItemImageFromData(const wxTreeItemId
& item
,
972 wxTreeItemIcon which
) const
974 wxTreeViewItem
tvItem(item
, TVIF_PARAM
);
975 if ( !DoGetItem(&tvItem
) )
980 return ((wxTreeItemIndirectData
*)tvItem
.lParam
)->GetImage(which
);
983 void wxTreeCtrl::DoSetItemImageFromData(const wxTreeItemId
& item
,
985 wxTreeItemIcon which
) const
987 wxTreeViewItem
tvItem(item
, TVIF_PARAM
);
988 if ( !DoGetItem(&tvItem
) )
993 wxTreeItemIndirectData
*data
= ((wxTreeItemIndirectData
*)tvItem
.lParam
);
995 data
->SetImage(image
, which
);
997 // make sure that we have selected images as well
998 if ( which
== wxTreeItemIcon_Normal
&&
999 !data
->HasImage(wxTreeItemIcon_Selected
) )
1001 data
->SetImage(image
, wxTreeItemIcon_Selected
);
1004 if ( which
== wxTreeItemIcon_Expanded
&&
1005 !data
->HasImage(wxTreeItemIcon_SelectedExpanded
) )
1007 data
->SetImage(image
, wxTreeItemIcon_SelectedExpanded
);
1011 void wxTreeCtrl::DoSetItemImages(const wxTreeItemId
& item
,
1015 wxTreeViewItem
tvItem(item
, TVIF_IMAGE
| TVIF_SELECTEDIMAGE
);
1016 tvItem
.iSelectedImage
= imageSel
;
1017 tvItem
.iImage
= image
;
1021 int wxTreeCtrl::GetItemImage(const wxTreeItemId
& item
,
1022 wxTreeItemIcon which
) const
1024 wxCHECK_MSG( item
.IsOk(), -1, wxT("invalid tree item") );
1026 if ( (HITEM(item
) == TVI_ROOT
) && (m_windowStyle
& wxTR_HIDE_ROOT
) )
1028 // TODO: Maybe a hidden root can still provide images?
1032 if ( HasIndirectData(item
) )
1034 return DoGetItemImageFromData(item
, which
);
1041 wxFAIL_MSG( wxT("unknown tree item image type") );
1043 case wxTreeItemIcon_Normal
:
1047 case wxTreeItemIcon_Selected
:
1048 mask
= TVIF_SELECTEDIMAGE
;
1051 case wxTreeItemIcon_Expanded
:
1052 case wxTreeItemIcon_SelectedExpanded
:
1056 wxTreeViewItem
tvItem(item
, mask
);
1059 return mask
== TVIF_IMAGE
? tvItem
.iImage
: tvItem
.iSelectedImage
;
1062 void wxTreeCtrl::SetItemImage(const wxTreeItemId
& item
, int image
,
1063 wxTreeItemIcon which
)
1065 wxCHECK_RET( item
.IsOk(), wxT("invalid tree item") );
1067 if ( IS_VIRTUAL_ROOT(item
) )
1069 // TODO: Maybe a hidden root can still store images?
1079 wxFAIL_MSG( wxT("unknown tree item image type") );
1082 case wxTreeItemIcon_Normal
:
1084 const int imageNormalOld
= GetItemImage(item
);
1085 const int imageSelOld
=
1086 GetItemImage(item
, wxTreeItemIcon_Selected
);
1088 // always set the normal image
1089 imageNormal
= image
;
1091 // if the selected and normal images were the same, they should
1092 // be the same after the update, otherwise leave the selected
1094 imageSel
= imageNormalOld
== imageSelOld
? image
: imageSelOld
;
1098 case wxTreeItemIcon_Selected
:
1099 imageNormal
= GetItemImage(item
);
1103 case wxTreeItemIcon_Expanded
:
1104 case wxTreeItemIcon_SelectedExpanded
:
1105 if ( !HasIndirectData(item
) )
1107 // we need to get the old images first, because after we create
1108 // the wxTreeItemIndirectData GetItemXXXImage() will use it to
1110 imageNormal
= GetItemImage(item
);
1111 imageSel
= GetItemImage(item
, wxTreeItemIcon_Selected
);
1113 // if it doesn't have it yet, add it
1114 wxTreeItemIndirectData
*data
= new
1115 wxTreeItemIndirectData(this, item
);
1117 // copy the data to the new location
1118 data
->SetImage(imageNormal
, wxTreeItemIcon_Normal
);
1119 data
->SetImage(imageSel
, wxTreeItemIcon_Selected
);
1122 DoSetItemImageFromData(item
, image
, which
);
1124 // reset the normal/selected images because we won't use them any
1125 // more - now they're stored inside the indirect data
1127 imageSel
= I_IMAGECALLBACK
;
1131 // NB: at least in version 5.00.0518.9 of comctl32.dll we need to always
1132 // change both normal and selected image - otherwise the change simply
1133 // doesn't take place!
1134 DoSetItemImages(item
, imageNormal
, imageSel
);
1137 wxTreeItemData
*wxTreeCtrl::GetItemData(const wxTreeItemId
& item
) const
1139 wxCHECK_MSG( item
.IsOk(), NULL
, wxT("invalid tree item") );
1141 wxTreeViewItem
tvItem(item
, TVIF_PARAM
);
1143 // Hidden root may have data.
1144 if ( IS_VIRTUAL_ROOT(item
) )
1146 return GET_VIRTUAL_ROOT()->GetData();
1150 if ( !DoGetItem(&tvItem
) )
1155 wxTreeItemData
*data
= (wxTreeItemData
*)tvItem
.lParam
;
1156 if ( IsDataIndirect(data
) )
1158 data
= ((wxTreeItemIndirectData
*)data
)->GetData();
1164 void wxTreeCtrl::SetItemData(const wxTreeItemId
& item
, wxTreeItemData
*data
)
1166 wxCHECK_RET( item
.IsOk(), wxT("invalid tree item") );
1168 if ( IS_VIRTUAL_ROOT(item
) )
1170 GET_VIRTUAL_ROOT()->SetData(data
);
1173 // first, associate this piece of data with this item
1179 wxTreeViewItem
tvItem(item
, TVIF_PARAM
);
1181 if ( HasIndirectData(item
) )
1183 if ( DoGetItem(&tvItem
) )
1185 ((wxTreeItemIndirectData
*)tvItem
.lParam
)->SetData(data
);
1189 wxFAIL_MSG( wxT("failed to change tree items data") );
1194 tvItem
.lParam
= (LPARAM
)data
;
1199 void wxTreeCtrl::SetIndirectItemData(const wxTreeItemId
& item
,
1200 wxTreeItemIndirectData
*data
)
1202 // this should never happen because it's unnecessary and will probably lead
1203 // to crash too because the code elsewhere supposes that the pointer the
1204 // wxTreeItemIndirectData has is a real wxItemData and not
1205 // wxTreeItemIndirectData as well
1206 wxASSERT_MSG( !HasIndirectData(item
), wxT("setting indirect data twice?") );
1208 SetItemData(item
, data
);
1211 bool wxTreeCtrl::HasIndirectData(const wxTreeItemId
& item
) const
1213 // query the item itself
1214 wxTreeViewItem
tvItem(item
, TVIF_PARAM
);
1215 if ( !DoGetItem(&tvItem
) )
1220 wxTreeItemData
*data
= (wxTreeItemData
*)tvItem
.lParam
;
1222 return data
&& IsDataIndirect(data
);
1225 void wxTreeCtrl::SetItemHasChildren(const wxTreeItemId
& item
, bool has
)
1227 wxCHECK_RET( item
.IsOk(), wxT("invalid tree item") );
1229 if ( IS_VIRTUAL_ROOT(item
) )
1232 wxTreeViewItem
tvItem(item
, TVIF_CHILDREN
);
1233 tvItem
.cChildren
= (int)has
;
1237 void wxTreeCtrl::SetItemBold(const wxTreeItemId
& item
, bool bold
)
1239 wxCHECK_RET( item
.IsOk(), wxT("invalid tree item") );
1241 if ( IS_VIRTUAL_ROOT(item
) )
1244 wxTreeViewItem
tvItem(item
, TVIF_STATE
, TVIS_BOLD
);
1245 tvItem
.state
= bold
? TVIS_BOLD
: 0;
1249 void wxTreeCtrl::SetItemDropHighlight(const wxTreeItemId
& item
, bool highlight
)
1251 if ( IS_VIRTUAL_ROOT(item
) )
1254 wxTreeViewItem
tvItem(item
, TVIF_STATE
, TVIS_DROPHILITED
);
1255 tvItem
.state
= highlight
? TVIS_DROPHILITED
: 0;
1259 void wxTreeCtrl::RefreshItem(const wxTreeItemId
& item
)
1261 if ( IS_VIRTUAL_ROOT(item
) )
1265 if ( GetBoundingRect(item
, rect
) )
1271 wxColour
wxTreeCtrl::GetItemTextColour(const wxTreeItemId
& item
) const
1273 wxCHECK_MSG( item
.IsOk(), wxNullColour
, wxT("invalid tree item") );
1275 wxMapTreeAttr::const_iterator it
= m_attrs
.find(item
.m_pItem
);
1276 return it
== m_attrs
.end() ? wxNullColour
: it
->second
->GetTextColour();
1279 wxColour
wxTreeCtrl::GetItemBackgroundColour(const wxTreeItemId
& item
) const
1281 wxCHECK_MSG( item
.IsOk(), wxNullColour
, wxT("invalid tree item") );
1283 wxMapTreeAttr::const_iterator it
= m_attrs
.find(item
.m_pItem
);
1284 return it
== m_attrs
.end() ? wxNullColour
: it
->second
->GetBackgroundColour();
1287 wxFont
wxTreeCtrl::GetItemFont(const wxTreeItemId
& item
) const
1289 wxCHECK_MSG( item
.IsOk(), wxNullFont
, wxT("invalid tree item") );
1291 wxMapTreeAttr::const_iterator it
= m_attrs
.find(item
.m_pItem
);
1292 return it
== m_attrs
.end() ? wxNullFont
: it
->second
->GetFont();
1295 void wxTreeCtrl::SetItemTextColour(const wxTreeItemId
& item
,
1296 const wxColour
& col
)
1298 wxCHECK_RET( item
.IsOk(), wxT("invalid tree item") );
1300 wxTreeItemAttr
*attr
;
1301 wxMapTreeAttr::iterator it
= m_attrs
.find(item
.m_pItem
);
1302 if ( it
== m_attrs
.end() )
1304 m_hasAnyAttr
= true;
1306 m_attrs
[item
.m_pItem
] =
1307 attr
= new wxTreeItemAttr
;
1314 attr
->SetTextColour(col
);
1319 void wxTreeCtrl::SetItemBackgroundColour(const wxTreeItemId
& item
,
1320 const wxColour
& col
)
1322 wxCHECK_RET( item
.IsOk(), wxT("invalid tree item") );
1324 wxTreeItemAttr
*attr
;
1325 wxMapTreeAttr::iterator it
= m_attrs
.find(item
.m_pItem
);
1326 if ( it
== m_attrs
.end() )
1328 m_hasAnyAttr
= true;
1330 m_attrs
[item
.m_pItem
] =
1331 attr
= new wxTreeItemAttr
;
1333 else // already in the hash
1338 attr
->SetBackgroundColour(col
);
1343 void wxTreeCtrl::SetItemFont(const wxTreeItemId
& item
, const wxFont
& font
)
1345 wxCHECK_RET( item
.IsOk(), wxT("invalid tree item") );
1347 wxTreeItemAttr
*attr
;
1348 wxMapTreeAttr::iterator it
= m_attrs
.find(item
.m_pItem
);
1349 if ( it
== m_attrs
.end() )
1351 m_hasAnyAttr
= true;
1353 m_attrs
[item
.m_pItem
] =
1354 attr
= new wxTreeItemAttr
;
1356 else // already in the hash
1361 attr
->SetFont(font
);
1366 // ----------------------------------------------------------------------------
1368 // ----------------------------------------------------------------------------
1370 bool wxTreeCtrl::IsVisible(const wxTreeItemId
& item
) const
1372 wxCHECK_MSG( item
.IsOk(), false, wxT("invalid tree item") );
1374 if ( item
== wxTreeItemId(TVI_ROOT
) )
1376 // virtual (hidden) root is never visible
1380 // Bug in Gnu-Win32 headers, so don't use the macro TreeView_GetItemRect
1383 // this ugliness comes directly from MSDN - it *is* the correct way to pass
1384 // the HTREEITEM with TVM_GETITEMRECT
1385 *(HTREEITEM
*)&rect
= HITEM(item
);
1387 // true means to get rect for just the text, not the whole line
1388 if ( !::SendMessage(GetHwnd(), TVM_GETITEMRECT
, true, (LPARAM
)&rect
) )
1390 // if TVM_GETITEMRECT returned false, then the item is definitely not
1391 // visible (because its parent is not expanded)
1395 // however if it returned true, the item might still be outside the
1396 // currently visible part of the tree, test for it (notice that partly
1397 // visible means visible here)
1398 return rect
.bottom
> 0 && rect
.top
< GetClientSize().y
;
1401 bool wxTreeCtrl::ItemHasChildren(const wxTreeItemId
& item
) const
1403 wxCHECK_MSG( item
.IsOk(), false, wxT("invalid tree item") );
1405 wxTreeViewItem
tvItem(item
, TVIF_CHILDREN
);
1408 return tvItem
.cChildren
!= 0;
1411 bool wxTreeCtrl::IsExpanded(const wxTreeItemId
& item
) const
1413 wxCHECK_MSG( item
.IsOk(), false, wxT("invalid tree item") );
1415 wxTreeViewItem
tvItem(item
, TVIF_STATE
, TVIS_EXPANDED
);
1418 return (tvItem
.state
& TVIS_EXPANDED
) != 0;
1421 bool wxTreeCtrl::IsSelected(const wxTreeItemId
& item
) const
1423 wxCHECK_MSG( item
.IsOk(), false, wxT("invalid tree item") );
1425 wxTreeViewItem
tvItem(item
, TVIF_STATE
, TVIS_SELECTED
);
1428 return (tvItem
.state
& TVIS_SELECTED
) != 0;
1431 bool wxTreeCtrl::IsBold(const wxTreeItemId
& item
) const
1433 wxCHECK_MSG( item
.IsOk(), false, wxT("invalid tree item") );
1435 wxTreeViewItem
tvItem(item
, TVIF_STATE
, TVIS_BOLD
);
1438 return (tvItem
.state
& TVIS_BOLD
) != 0;
1441 // ----------------------------------------------------------------------------
1443 // ----------------------------------------------------------------------------
1445 wxTreeItemId
wxTreeCtrl::GetRootItem() const
1447 // Root may be real (visible) or virtual (hidden).
1448 if ( GET_VIRTUAL_ROOT() )
1451 return wxTreeItemId(TreeView_GetRoot(GetHwnd()));
1454 wxTreeItemId
wxTreeCtrl::GetSelection() const
1456 wxCHECK_MSG( !(m_windowStyle
& wxTR_MULTIPLE
), wxTreeItemId(),
1457 wxT("this only works with single selection controls") );
1459 return wxTreeItemId(TreeView_GetSelection(GetHwnd()));
1462 wxTreeItemId
wxTreeCtrl::GetItemParent(const wxTreeItemId
& item
) const
1464 wxCHECK_MSG( item
.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1468 if ( IS_VIRTUAL_ROOT(item
) )
1470 // no parent for the virtual root
1475 hItem
= TreeView_GetParent(GetHwnd(), HITEM(item
));
1476 if ( !hItem
&& HasFlag(wxTR_HIDE_ROOT
) )
1478 // the top level items should have the virtual root as their parent
1483 return wxTreeItemId(hItem
);
1486 wxTreeItemId
wxTreeCtrl::GetFirstChild(const wxTreeItemId
& item
,
1487 wxTreeItemIdValue
& cookie
) const
1489 wxCHECK_MSG( item
.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1491 // remember the last child returned in 'cookie'
1492 cookie
= TreeView_GetChild(GetHwnd(), HITEM(item
));
1494 return wxTreeItemId(cookie
);
1497 wxTreeItemId
wxTreeCtrl::GetNextChild(const wxTreeItemId
& WXUNUSED(item
),
1498 wxTreeItemIdValue
& cookie
) const
1500 wxTreeItemId
fromCookie(cookie
);
1502 HTREEITEM hitem
= HITEM(fromCookie
);
1504 hitem
= TreeView_GetNextSibling(GetHwnd(), hitem
);
1506 wxTreeItemId
item(hitem
);
1508 cookie
= item
.m_pItem
;
1513 #if WXWIN_COMPATIBILITY_2_4
1515 wxTreeItemId
wxTreeCtrl::GetFirstChild(const wxTreeItemId
& item
,
1518 wxCHECK_MSG( item
.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1520 cookie
= (long)TreeView_GetChild(GetHwnd(), HITEM(item
));
1522 return wxTreeItemId((void *)cookie
);
1525 wxTreeItemId
wxTreeCtrl::GetNextChild(const wxTreeItemId
& WXUNUSED(item
),
1528 wxTreeItemId
fromCookie((void *)cookie
);
1530 HTREEITEM hitem
= HITEM(fromCookie
);
1532 hitem
= TreeView_GetNextSibling(GetHwnd(), hitem
);
1534 wxTreeItemId
item(hitem
);
1536 cookie
= (long)item
.m_pItem
;
1541 #endif // WXWIN_COMPATIBILITY_2_4
1543 wxTreeItemId
wxTreeCtrl::GetLastChild(const wxTreeItemId
& item
) const
1545 wxCHECK_MSG( item
.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1547 // can this be done more efficiently?
1548 wxTreeItemIdValue cookie
;
1550 wxTreeItemId childLast
,
1551 child
= GetFirstChild(item
, cookie
);
1552 while ( child
.IsOk() )
1555 child
= GetNextChild(item
, cookie
);
1561 wxTreeItemId
wxTreeCtrl::GetNextSibling(const wxTreeItemId
& item
) const
1563 wxCHECK_MSG( item
.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1564 return wxTreeItemId(TreeView_GetNextSibling(GetHwnd(), HITEM(item
)));
1567 wxTreeItemId
wxTreeCtrl::GetPrevSibling(const wxTreeItemId
& item
) const
1569 wxCHECK_MSG( item
.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1570 return wxTreeItemId(TreeView_GetPrevSibling(GetHwnd(), HITEM(item
)));
1573 wxTreeItemId
wxTreeCtrl::GetFirstVisibleItem() const
1575 return wxTreeItemId(TreeView_GetFirstVisible(GetHwnd()));
1578 wxTreeItemId
wxTreeCtrl::GetNextVisible(const wxTreeItemId
& item
) const
1580 wxCHECK_MSG( item
.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1581 wxASSERT_MSG( IsVisible(item
), wxT("The item you call GetNextVisible() for must be visible itself!"));
1583 return wxTreeItemId(TreeView_GetNextVisible(GetHwnd(), HITEM(item
)));
1586 wxTreeItemId
wxTreeCtrl::GetPrevVisible(const wxTreeItemId
& item
) const
1588 wxCHECK_MSG( item
.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1589 wxASSERT_MSG( IsVisible(item
), wxT("The item you call GetPrevVisible() for must be visible itself!"));
1591 return wxTreeItemId(TreeView_GetPrevVisible(GetHwnd(), HITEM(item
)));
1594 // ----------------------------------------------------------------------------
1595 // multiple selections emulation
1596 // ----------------------------------------------------------------------------
1598 bool wxTreeCtrl::IsItemChecked(const wxTreeItemId
& item
) const
1600 wxCHECK_MSG( item
.IsOk(), false, wxT("invalid tree item") );
1602 // receive the desired information.
1603 wxTreeViewItem
tvItem(item
, TVIF_STATE
, TVIS_STATEIMAGEMASK
);
1606 // state image indices are 1 based
1607 return ((tvItem
.state
>> 12) - 1) == 1;
1610 void wxTreeCtrl::SetItemCheck(const wxTreeItemId
& item
, bool check
)
1612 wxCHECK_RET( item
.IsOk(), wxT("invalid tree item") );
1614 // receive the desired information.
1615 wxTreeViewItem
tvItem(item
, TVIF_STATE
, TVIS_STATEIMAGEMASK
);
1619 // state images are one-based
1620 tvItem
.state
= (check
? 2 : 1) << 12;
1625 size_t wxTreeCtrl::GetSelections(wxArrayTreeItemIds
& selections
) const
1627 TraverseSelections
selector(this, selections
);
1629 return selector
.GetCount();
1632 // ----------------------------------------------------------------------------
1634 // ----------------------------------------------------------------------------
1636 wxTreeItemId
wxTreeCtrl::DoInsertItem(const wxTreeItemId
& parent
,
1637 wxTreeItemId hInsertAfter
,
1638 const wxString
& text
,
1639 int image
, int selectedImage
,
1640 wxTreeItemData
*data
)
1642 wxCHECK_MSG( parent
.IsOk() || !TreeView_GetRoot(GetHwnd()),
1644 _T("can't have more than one root in the tree") );
1646 TV_INSERTSTRUCT tvIns
;
1647 tvIns
.hParent
= HITEM(parent
);
1648 tvIns
.hInsertAfter
= HITEM(hInsertAfter
);
1650 // this is how we insert the item as the first child: supply a NULL
1652 if ( !tvIns
.hInsertAfter
)
1654 tvIns
.hInsertAfter
= TVI_FIRST
;
1658 if ( !text
.empty() )
1661 tvIns
.item
.pszText
= (wxChar
*)text
.c_str(); // cast is ok
1665 tvIns
.item
.pszText
= NULL
;
1666 tvIns
.item
.cchTextMax
= 0;
1672 tvIns
.item
.iImage
= image
;
1674 if ( selectedImage
== -1 )
1676 // take the same image for selected icon if not specified
1677 selectedImage
= image
;
1681 if ( selectedImage
!= -1 )
1683 mask
|= TVIF_SELECTEDIMAGE
;
1684 tvIns
.item
.iSelectedImage
= selectedImage
;
1690 tvIns
.item
.lParam
= (LPARAM
)data
;
1693 tvIns
.item
.mask
= mask
;
1695 HTREEITEM id
= (HTREEITEM
) TreeView_InsertItem(GetHwnd(), &tvIns
);
1698 wxLogLastError(wxT("TreeView_InsertItem"));
1703 // associate the application tree item with Win32 tree item handle
1707 return wxTreeItemId(id
);
1710 // for compatibility only
1711 #if WXWIN_COMPATIBILITY_2_4
1713 wxTreeItemId
wxTreeCtrl::InsertItem(const wxTreeItemId
& parent
,
1714 const wxString
& text
,
1715 int image
, int selImage
,
1718 return DoInsertItem(parent
, wxTreeItemId((void *)insertAfter
), text
,
1719 image
, selImage
, NULL
);
1722 #endif // WXWIN_COMPATIBILITY_2_4
1724 wxTreeItemId
wxTreeCtrl::AddRoot(const wxString
& text
,
1725 int image
, int selectedImage
,
1726 wxTreeItemData
*data
)
1729 if ( m_windowStyle
& wxTR_HIDE_ROOT
)
1731 // create a virtual root item, the parent for all the others
1732 m_pVirtualRoot
= new wxVirtualNode(data
);
1737 return DoInsertItem(wxTreeItemId(), wxTreeItemId(),
1738 text
, image
, selectedImage
, data
);
1741 wxTreeItemId
wxTreeCtrl::PrependItem(const wxTreeItemId
& parent
,
1742 const wxString
& text
,
1743 int image
, int selectedImage
,
1744 wxTreeItemData
*data
)
1746 return DoInsertItem(parent
, TVI_FIRST
,
1747 text
, image
, selectedImage
, data
);
1750 wxTreeItemId
wxTreeCtrl::InsertItem(const wxTreeItemId
& parent
,
1751 const wxTreeItemId
& idPrevious
,
1752 const wxString
& text
,
1753 int image
, int selectedImage
,
1754 wxTreeItemData
*data
)
1756 return DoInsertItem(parent
, idPrevious
, text
, image
, selectedImage
, data
);
1759 wxTreeItemId
wxTreeCtrl::InsertItem(const wxTreeItemId
& parent
,
1761 const wxString
& text
,
1762 int image
, int selectedImage
,
1763 wxTreeItemData
*data
)
1765 // find the item from index
1766 wxTreeItemIdValue cookie
;
1767 wxTreeItemId idPrev
, idCur
= GetFirstChild(parent
, cookie
);
1768 while ( index
!= 0 && idCur
.IsOk() )
1773 idCur
= GetNextChild(parent
, cookie
);
1776 // assert, not check: if the index is invalid, we will append the item
1778 wxASSERT_MSG( index
== 0, _T("bad index in wxTreeCtrl::InsertItem") );
1780 return DoInsertItem(parent
, idPrev
, text
, image
, selectedImage
, data
);
1783 wxTreeItemId
wxTreeCtrl::AppendItem(const wxTreeItemId
& parent
,
1784 const wxString
& text
,
1785 int image
, int selectedImage
,
1786 wxTreeItemData
*data
)
1788 return DoInsertItem(parent
, TVI_LAST
,
1789 text
, image
, selectedImage
, data
);
1792 void wxTreeCtrl::Delete(const wxTreeItemId
& item
)
1794 if ( !TreeView_DeleteItem(GetHwnd(), HITEM(item
)) )
1796 wxLogLastError(wxT("TreeView_DeleteItem"));
1800 // delete all children (but don't delete the item itself)
1801 void wxTreeCtrl::DeleteChildren(const wxTreeItemId
& item
)
1803 wxTreeItemIdValue cookie
;
1805 wxArrayTreeItemIds children
;
1806 wxTreeItemId child
= GetFirstChild(item
, cookie
);
1807 while ( child
.IsOk() )
1809 children
.Add(child
);
1811 child
= GetNextChild(item
, cookie
);
1814 size_t nCount
= children
.Count();
1815 for ( size_t n
= 0; n
< nCount
; n
++ )
1817 if ( !TreeView_DeleteItem(GetHwnd(), HITEM_PTR(children
[n
])) )
1819 wxLogLastError(wxT("TreeView_DeleteItem"));
1824 void wxTreeCtrl::DeleteAllItems()
1826 // delete the "virtual" root item.
1827 if ( GET_VIRTUAL_ROOT() )
1829 delete GET_VIRTUAL_ROOT();
1830 m_pVirtualRoot
= NULL
;
1833 // and all the real items
1835 if ( !TreeView_DeleteAllItems(GetHwnd()) )
1837 wxLogLastError(wxT("TreeView_DeleteAllItems"));
1841 void wxTreeCtrl::DoExpand(const wxTreeItemId
& item
, int flag
)
1843 wxASSERT_MSG( flag
== TVE_COLLAPSE
||
1844 flag
== (TVE_COLLAPSE
| TVE_COLLAPSERESET
) ||
1845 flag
== TVE_EXPAND
||
1847 wxT("Unknown flag in wxTreeCtrl::DoExpand") );
1849 // A hidden root can be neither expanded nor collapsed.
1850 wxCHECK_RET( !(m_windowStyle
& wxTR_HIDE_ROOT
) || (HITEM(item
) != TVI_ROOT
),
1851 wxT("Can't expand/collapse hidden root node!") )
1853 // TreeView_Expand doesn't send TVN_ITEMEXPAND(ING) messages, so we must
1854 // emulate them. This behaviour has changed slightly with comctl32.dll
1855 // v 4.70 - now it does send them but only the first time. To maintain
1856 // compatible behaviour and also in order to not have surprises with the
1857 // future versions, don't rely on this and still do everything ourselves.
1858 // To avoid that the messages be sent twice when the item is expanded for
1859 // the first time we must clear TVIS_EXPANDEDONCE style manually.
1861 wxTreeViewItem
tvItem(item
, TVIF_STATE
, TVIS_EXPANDEDONCE
);
1865 if ( TreeView_Expand(GetHwnd(), HITEM(item
), flag
) != 0 )
1867 wxTreeEvent
event(wxEVT_NULL
, m_windowId
);
1868 event
.m_item
= item
;
1869 event
.SetEventObject(this);
1871 // note that the {EXPAND|COLLAPS}ING event is sent by TreeView_Expand()
1873 event
.SetEventType(gs_expandEvents
[IsExpanded(item
) ? IDX_EXPAND
1877 (void)GetEventHandler()->ProcessEvent(event
);
1879 //else: change didn't took place, so do nothing at all
1882 void wxTreeCtrl::Expand(const wxTreeItemId
& item
)
1884 DoExpand(item
, TVE_EXPAND
);
1887 void wxTreeCtrl::Collapse(const wxTreeItemId
& item
)
1889 DoExpand(item
, TVE_COLLAPSE
);
1892 void wxTreeCtrl::CollapseAndReset(const wxTreeItemId
& item
)
1894 DoExpand(item
, TVE_COLLAPSE
| TVE_COLLAPSERESET
);
1897 void wxTreeCtrl::Toggle(const wxTreeItemId
& item
)
1899 DoExpand(item
, TVE_TOGGLE
);
1902 #if WXWIN_COMPATIBILITY_2_4
1903 void wxTreeCtrl::ExpandItem(const wxTreeItemId
& item
, int action
)
1905 DoExpand(item
, action
);
1909 void wxTreeCtrl::Unselect()
1911 wxASSERT_MSG( !(m_windowStyle
& wxTR_MULTIPLE
),
1912 wxT("doesn't make sense, may be you want UnselectAll()?") );
1914 // just remove the selection
1915 SelectItem(wxTreeItemId());
1918 void wxTreeCtrl::UnselectAll()
1920 if ( m_windowStyle
& wxTR_MULTIPLE
)
1922 wxArrayTreeItemIds selections
;
1923 size_t count
= GetSelections(selections
);
1924 for ( size_t n
= 0; n
< count
; n
++ )
1926 #if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1927 SetItemCheck(HITEM_PTR(selections
[n
]), false);
1928 #else // !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1929 ::UnselectItem(GetHwnd(), HITEM_PTR(selections
[n
]));
1930 #endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE/!wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1935 // just remove the selection
1940 void wxTreeCtrl::SelectItem(const wxTreeItemId
& item
, bool select
)
1942 if ( m_windowStyle
& wxTR_MULTIPLE
)
1944 #if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1945 // selecting the item means checking it
1946 SetItemCheck(item
, select
);
1947 #else // !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1948 ::SelectItem(GetHwnd(), HITEM(item
), select
);
1949 #endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE/!wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1953 wxASSERT_MSG( select
,
1954 _T("SelectItem(false) works only for multiselect") );
1956 // inspite of the docs (MSDN Jan 99 edition), we don't seem to receive
1957 // the notification from the control (i.e. TVN_SELCHANG{ED|ING}), so
1958 // send them ourselves
1960 wxTreeEvent
event(wxEVT_NULL
, m_windowId
);
1961 event
.m_item
= item
;
1962 event
.SetEventObject(this);
1964 event
.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGING
);
1965 if ( !GetEventHandler()->ProcessEvent(event
) || event
.IsAllowed() )
1967 if ( !TreeView_SelectItem(GetHwnd(), HITEM(item
)) )
1969 wxLogLastError(wxT("TreeView_SelectItem"));
1973 event
.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED
);
1974 (void)GetEventHandler()->ProcessEvent(event
);
1977 //else: program vetoed the change
1981 void wxTreeCtrl::UnselectItem(const wxTreeItemId
& item
)
1983 SelectItem(item
, false);
1986 void wxTreeCtrl::ToggleItemSelection(const wxTreeItemId
& item
)
1988 SelectItem(item
, !IsSelected(item
));
1991 void wxTreeCtrl::EnsureVisible(const wxTreeItemId
& item
)
1994 TreeView_EnsureVisible(GetHwnd(), HITEM(item
));
1997 void wxTreeCtrl::ScrollTo(const wxTreeItemId
& item
)
1999 if ( !TreeView_SelectSetFirstVisible(GetHwnd(), HITEM(item
)) )
2001 wxLogLastError(wxT("TreeView_SelectSetFirstVisible"));
2005 wxTextCtrl
*wxTreeCtrl::GetEditControl() const
2010 void wxTreeCtrl::DeleteTextCtrl()
2014 // the HWND corresponding to this control is deleted by the tree
2015 // control itself and we don't know when exactly this happens, so check
2016 // if the window still exists before calling UnsubclassWin()
2017 if ( !::IsWindow(GetHwndOf(m_textCtrl
)) )
2019 m_textCtrl
->SetHWND(0);
2022 m_textCtrl
->UnsubclassWin();
2023 m_textCtrl
->SetHWND(0);
2031 wxTextCtrl
* wxTreeCtrl::EditLabel(const wxTreeItemId
& item
,
2032 wxClassInfo
* textControlClass
)
2034 wxASSERT( textControlClass
->IsKindOf(CLASSINFO(wxTextCtrl
)) );
2039 m_textCtrl
= (wxTextCtrl
*)textControlClass
->CreateObject();
2040 HWND hWnd
= (HWND
) TreeView_EditLabel(GetHwnd(), HITEM(item
));
2042 // this is not an error - the TVN_BEGINLABELEDIT handler might have
2051 // textctrl is subclassed in MSWOnNotify
2055 // End label editing, optionally cancelling the edit
2056 void wxTreeCtrl::DoEndEditLabel(bool discardChanges
)
2058 TreeView_EndEditLabelNow(GetHwnd(), discardChanges
);
2063 wxTreeItemId
wxTreeCtrl::HitTest(const wxPoint
& point
, int& flags
)
2065 TV_HITTESTINFO hitTestInfo
;
2066 hitTestInfo
.pt
.x
= (int)point
.x
;
2067 hitTestInfo
.pt
.y
= (int)point
.y
;
2069 TreeView_HitTest(GetHwnd(), &hitTestInfo
);
2074 #define TRANSLATE_FLAG(flag) if ( hitTestInfo.flags & TVHT_##flag ) \
2075 flags |= wxTREE_HITTEST_##flag
2077 TRANSLATE_FLAG(ABOVE
);
2078 TRANSLATE_FLAG(BELOW
);
2079 TRANSLATE_FLAG(NOWHERE
);
2080 TRANSLATE_FLAG(ONITEMBUTTON
);
2081 TRANSLATE_FLAG(ONITEMICON
);
2082 TRANSLATE_FLAG(ONITEMINDENT
);
2083 TRANSLATE_FLAG(ONITEMLABEL
);
2084 TRANSLATE_FLAG(ONITEMRIGHT
);
2085 TRANSLATE_FLAG(ONITEMSTATEICON
);
2086 TRANSLATE_FLAG(TOLEFT
);
2087 TRANSLATE_FLAG(TORIGHT
);
2089 #undef TRANSLATE_FLAG
2091 return wxTreeItemId(hitTestInfo
.hItem
);
2094 bool wxTreeCtrl::GetBoundingRect(const wxTreeItemId
& item
,
2096 bool textOnly
) const
2100 // Virtual root items have no bounding rectangle
2101 if ( IS_VIRTUAL_ROOT(item
) )
2106 if ( TreeView_GetItemRect(GetHwnd(), HITEM(item
),
2109 rect
= wxRect(wxPoint(rc
.left
, rc
.top
), wxPoint(rc
.right
, rc
.bottom
));
2115 // couldn't retrieve rect: for example, item isn't visible
2120 // ----------------------------------------------------------------------------
2122 // ----------------------------------------------------------------------------
2124 // this is just a tiny namespace which is friend to wxTreeCtrl and so can use
2125 // functions such as IsDataIndirect()
2126 class wxTreeSortHelper
2129 static int CALLBACK
Compare(LPARAM data1
, LPARAM data2
, LPARAM tree
);
2132 static wxTreeItemId
GetIdFromData(wxTreeCtrl
*tree
, LPARAM item
)
2134 wxTreeItemData
*data
= (wxTreeItemData
*)item
;
2135 if ( tree
->IsDataIndirect(data
) )
2137 data
= ((wxTreeItemIndirectData
*)data
)->GetData();
2140 return data
->GetId();
2144 int CALLBACK
wxTreeSortHelper::Compare(LPARAM pItem1
,
2148 wxCHECK_MSG( pItem1
&& pItem2
, 0,
2149 wxT("sorting tree without data doesn't make sense") );
2151 wxTreeCtrl
*tree
= (wxTreeCtrl
*)htree
;
2153 return tree
->OnCompareItems(GetIdFromData(tree
, pItem1
),
2154 GetIdFromData(tree
, pItem2
));
2157 int wxTreeCtrl::OnCompareItems(const wxTreeItemId
& item1
,
2158 const wxTreeItemId
& item2
)
2160 return wxStrcmp(GetItemText(item1
), GetItemText(item2
));
2163 void wxTreeCtrl::SortChildren(const wxTreeItemId
& item
)
2165 wxCHECK_RET( item
.IsOk(), wxT("invalid tree item") );
2167 // rely on the fact that TreeView_SortChildren does the same thing as our
2168 // default behaviour, i.e. sorts items alphabetically and so call it
2169 // directly if we're not in derived class (much more efficient!)
2170 if ( GetClassInfo() == CLASSINFO(wxTreeCtrl
) )
2172 TreeView_SortChildren(GetHwnd(), HITEM(item
), 0);
2177 tvSort
.hParent
= HITEM(item
);
2178 tvSort
.lpfnCompare
= wxTreeSortHelper::Compare
;
2179 tvSort
.lParam
= (LPARAM
)this;
2180 TreeView_SortChildrenCB(GetHwnd(), &tvSort
, 0 /* reserved */);
2184 // ----------------------------------------------------------------------------
2186 // ----------------------------------------------------------------------------
2188 bool wxTreeCtrl::MSWCommand(WXUINT cmd
, WXWORD id
)
2190 if ( cmd
== EN_UPDATE
)
2192 wxCommandEvent
event(wxEVT_COMMAND_TEXT_UPDATED
, id
);
2193 event
.SetEventObject( this );
2194 ProcessCommand(event
);
2196 else if ( cmd
== EN_KILLFOCUS
)
2198 wxCommandEvent
event(wxEVT_KILL_FOCUS
, id
);
2199 event
.SetEventObject( this );
2200 ProcessCommand(event
);
2208 // command processed
2212 // we hook into WndProc to process WM_MOUSEMOVE/WM_BUTTONUP messages - as we
2213 // only do it during dragging, minimize wxWin overhead (this is important for
2214 // WM_MOUSEMOVE as they're a lot of them) by catching Windows messages directly
2215 // instead of passing by wxWin events
2216 WXLRESULT
wxTreeCtrl::MSWWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
2218 bool processed
= false;
2220 bool isMultiple
= (GetWindowStyle() & wxTR_MULTIPLE
) != 0;
2222 #ifndef __SMARTPHONE__
2223 if (nMsg
== WM_CONTEXTMENU
)
2225 wxTreeEvent
event( wxEVT_COMMAND_TREE_ITEM_MENU
, GetId() );
2226 event
.m_item
= GetSelection();
2227 event
.SetEventObject( this );
2228 GetEventHandler()->ProcessEvent( event
);
2232 #endif // __SMARTPHONE__
2234 if ( (nMsg
>= WM_MOUSEFIRST
) && (nMsg
<= WM_MOUSELAST
) )
2236 // we only process mouse messages here and these parameters have the
2237 // same meaning for all of them
2238 int x
= GET_X_LPARAM(lParam
),
2239 y
= GET_Y_LPARAM(lParam
);
2240 HTREEITEM htItem
= GetItemFromPoint(GetHwnd(), x
, y
);
2244 case WM_RBUTTONDOWN
:
2245 // if the item we are about to right click on is not already
2246 // selected or if we click outside of any item, remove the
2247 // entire previous selection
2248 if ( !htItem
|| !::IsItemSelected(GetHwnd(), htItem
) )
2253 // select item and set the focus to the
2254 // newly selected item
2255 ::SelectItem(GetHwnd(), htItem
);
2256 ::SetFocus(GetHwnd(), htItem
);
2259 #if !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
2260 case WM_LBUTTONDOWN
:
2261 if ( htItem
&& isMultiple
)
2263 if ( wParam
& MK_CONTROL
)
2267 // toggle selected state
2268 ::ToggleItemSelection(GetHwnd(), htItem
);
2270 ::SetFocus(GetHwnd(), htItem
);
2272 // reset on any click without Shift
2273 m_htSelStart
.Unset();
2277 else if ( wParam
& MK_SHIFT
)
2279 // this selects all items between the starting one and
2282 if ( !m_htSelStart
)
2284 // take the focused item
2285 m_htSelStart
= TreeView_GetSelection(GetHwnd());
2288 SelectRange(GetHwnd(), HITEM(m_htSelStart
), htItem
,
2289 !(wParam
& MK_CONTROL
));
2291 ::SetFocus(GetHwnd(), htItem
);
2295 else // normal click
2297 // avoid doing anything if we click on the only
2298 // currently selected item
2300 wxArrayTreeItemIds selections
;
2301 size_t count
= GetSelections(selections
);
2304 HITEM_PTR(selections
[0]) != htItem
)
2306 // clear the previously selected items, if the
2307 // user clicked outside of the present selection.
2308 // otherwise, perform the deselection on mouse-up.
2309 // this allows multiple drag and drop to work.
2311 if (IsItemSelected(GetHwnd(), htItem
))
2313 ::SetFocus(GetHwnd(), htItem
);
2319 // prevent the click from starting in-place editing
2320 // which should only happen if we click on the
2321 // already selected item (and nothing else is
2324 TreeView_SelectItem(GetHwnd(), 0);
2325 ::SelectItem(GetHwnd(), htItem
);
2329 // reset on any click without Shift
2330 m_htSelStart
.Unset();
2334 #endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
2339 m_dragImage
->Move(wxPoint(x
, y
));
2342 // highlight the item as target (hiding drag image is
2343 // necessary - otherwise the display will be corrupted)
2344 m_dragImage
->Hide();
2345 TreeView_SelectDropTarget(GetHwnd(), htItem
);
2346 m_dragImage
->Show();
2353 // facilitates multiple drag-and-drop
2354 if (htItem
&& isMultiple
)
2356 wxArrayTreeItemIds selections
;
2357 size_t count
= GetSelections(selections
);
2360 !(wParam
& MK_CONTROL
) &&
2361 !(wParam
& MK_SHIFT
))
2364 TreeView_SelectItem(GetHwnd(), htItem
);
2373 m_dragImage
->EndDrag();
2377 // generate the drag end event
2378 wxTreeEvent
event(wxEVT_COMMAND_TREE_END_DRAG
, m_windowId
);
2380 event
.m_item
= htItem
;
2381 event
.m_pointDrag
= wxPoint(x
, y
);
2382 event
.SetEventObject(this);
2384 (void)GetEventHandler()->ProcessEvent(event
);
2386 // if we don't do it, the tree seems to think that 2 items
2387 // are selected simultaneously which is quite weird
2388 TreeView_SelectDropTarget(GetHwnd(), 0);
2393 #if !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
2394 else if ( (nMsg
== WM_SETFOCUS
|| nMsg
== WM_KILLFOCUS
) && isMultiple
)
2396 // the tree control greys out the selected item when it loses focus and
2397 // paints it as selected again when it regains it, but it won't do it
2398 // for the other items itself - help it
2399 wxArrayTreeItemIds selections
;
2400 size_t count
= GetSelections(selections
);
2402 for ( size_t n
= 0; n
< count
; n
++ )
2404 // TreeView_GetItemRect() will return false if item is not visible,
2405 // which may happen perfectly well
2406 if ( TreeView_GetItemRect(GetHwnd(), HITEM_PTR(selections
[n
]),
2409 ::InvalidateRect(GetHwnd(), &rect
, false);
2413 else if ( nMsg
== WM_KEYDOWN
&& isMultiple
)
2415 bool bCtrl
= wxIsCtrlDown(),
2416 bShift
= wxIsShiftDown();
2418 // we handle.arrows and space, but not page up/down and home/end: the
2419 // latter should be easy, but not the former
2421 HTREEITEM htSel
= (HTREEITEM
)TreeView_GetSelection(GetHwnd());
2422 if ( !m_htSelStart
)
2424 m_htSelStart
= htSel
;
2427 if ( wParam
== VK_SPACE
)
2431 ::ToggleItemSelection(GetHwnd(), htSel
);
2437 ::SelectItem(GetHwnd(), htSel
);
2442 else if ( wParam
== VK_UP
|| wParam
== VK_DOWN
)
2444 if ( !bCtrl
&& !bShift
)
2446 // no modifiers, just clear selection and then let the default
2447 // processing to take place
2452 (void)wxControl::MSWWindowProc(nMsg
, wParam
, lParam
);
2454 HTREEITEM htNext
= (HTREEITEM
)(wParam
== VK_UP
2455 ? TreeView_GetPrevVisible(GetHwnd(), htSel
)
2456 : TreeView_GetNextVisible(GetHwnd(), htSel
));
2460 // at the top/bottom
2466 SelectRange(GetHwnd(), HITEM(m_htSelStart
), htNext
);
2470 // without changing selection
2471 ::SetFocus(GetHwnd(), htNext
);
2478 #endif // !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
2479 else if ( nMsg
== WM_CHAR
)
2481 // don't let the control process Space and Return keys because it
2482 // doesn't do anything useful with them anyhow but always beeps
2483 // annoyingly when it receives them and there is no way to turn it off
2484 // simply if you just process TREEITEM_ACTIVATED event to which Space
2485 // and Enter presses are mapped in your code
2486 if ( wParam
== VK_SPACE
|| wParam
== VK_RETURN
)
2491 else if ( nMsg
== WM_COMMAND
)
2493 // if we receive a EN_KILLFOCUS command from the in-place edit control
2494 // used for label editing, make sure to end editing
2497 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2499 if ( cmd
== EN_KILLFOCUS
)
2501 if ( m_textCtrl
&& m_textCtrl
->GetHandle() == hwnd
)
2511 rc
= wxControl::MSWWindowProc(nMsg
, wParam
, lParam
);
2516 // process WM_NOTIFY Windows message
2517 bool wxTreeCtrl::MSWOnNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
2519 wxTreeEvent
event(wxEVT_NULL
, m_windowId
);
2520 wxEventType eventType
= wxEVT_NULL
;
2521 NMHDR
*hdr
= (NMHDR
*)lParam
;
2523 switch ( hdr
->code
)
2526 eventType
= wxEVT_COMMAND_TREE_BEGIN_DRAG
;
2529 case TVN_BEGINRDRAG
:
2531 if ( eventType
== wxEVT_NULL
)
2532 eventType
= wxEVT_COMMAND_TREE_BEGIN_RDRAG
;
2533 //else: left drag, already set above
2535 NM_TREEVIEW
*tv
= (NM_TREEVIEW
*)lParam
;
2537 event
.m_item
= tv
->itemNew
.hItem
;
2538 event
.m_pointDrag
= wxPoint(tv
->ptDrag
.x
, tv
->ptDrag
.y
);
2540 // don't allow dragging by default: the user code must
2541 // explicitly say that it wants to allow it to avoid breaking
2547 case TVN_BEGINLABELEDIT
:
2549 eventType
= wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT
;
2550 TV_DISPINFO
*info
= (TV_DISPINFO
*)lParam
;
2552 event
.m_item
= info
->item
.hItem
;
2553 event
.m_label
= info
->item
.pszText
;
2554 event
.m_editCancelled
= false;
2558 case TVN_DELETEITEM
:
2560 eventType
= wxEVT_COMMAND_TREE_DELETE_ITEM
;
2561 NM_TREEVIEW
*tv
= (NM_TREEVIEW
*)lParam
;
2563 event
.m_item
= tv
->itemOld
.hItem
;
2567 wxMapTreeAttr::iterator it
= m_attrs
.find(tv
->itemOld
.hItem
);
2568 if ( it
!= m_attrs
.end() )
2577 case TVN_ENDLABELEDIT
:
2579 eventType
= wxEVT_COMMAND_TREE_END_LABEL_EDIT
;
2580 TV_DISPINFO
*info
= (TV_DISPINFO
*)lParam
;
2582 event
.m_item
= info
->item
.hItem
;
2583 event
.m_label
= info
->item
.pszText
;
2584 event
.m_editCancelled
= info
->item
.pszText
== NULL
;
2589 // These *must* not be removed or TVN_GETINFOTIP will
2590 // not be processed each time the mouse is moved
2591 // and the tooltip will only ever update once.
2600 case TVN_GETINFOTIP
:
2602 eventType
= wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP
;
2603 NMTVGETINFOTIP
*info
= (NMTVGETINFOTIP
*)lParam
;
2605 // Which item are we trying to get a tooltip for?
2606 event
.m_item
= info
->hItem
;
2612 case TVN_GETDISPINFO
:
2613 eventType
= wxEVT_COMMAND_TREE_GET_INFO
;
2616 case TVN_SETDISPINFO
:
2618 if ( eventType
== wxEVT_NULL
)
2619 eventType
= wxEVT_COMMAND_TREE_SET_INFO
;
2620 //else: get, already set above
2622 TV_DISPINFO
*info
= (TV_DISPINFO
*)lParam
;
2624 event
.m_item
= info
->item
.hItem
;
2628 case TVN_ITEMEXPANDING
:
2629 case TVN_ITEMEXPANDED
:
2631 NM_TREEVIEW
* tv
= (NM_TREEVIEW
*)lParam
;
2634 switch ( tv
->action
)
2637 wxLogDebug(wxT("unexpected code %d in TVN_ITEMEXPAND message"), tv
->action
);
2645 what
= IDX_COLLAPSE
;
2649 int how
= hdr
->code
== TVN_ITEMEXPANDING
? IDX_DOING
2652 eventType
= gs_expandEvents
[what
][how
];
2654 event
.m_item
= tv
->itemNew
.hItem
;
2660 eventType
= wxEVT_COMMAND_TREE_KEY_DOWN
;
2661 TV_KEYDOWN
*info
= (TV_KEYDOWN
*)lParam
;
2663 // fabricate the lParam and wParam parameters sufficiently
2664 // similar to the ones from a "real" WM_KEYDOWN so that
2665 // CreateKeyEvent() works correctly
2667 (::GetKeyState(VK_MENU
) < 0 ? KF_ALTDOWN
: 0) << 16;
2669 WXWPARAM wParam
= info
->wVKey
;
2671 int keyCode
= wxCharCodeMSWToWX(info
->wVKey
);
2674 // wxCharCodeMSWToWX() returns 0 to indicate that this is a
2679 event
.m_evtKey
= CreateKeyEvent(wxEVT_KEY_DOWN
,
2684 // a separate event for Space/Return
2685 if ( !wxIsCtrlDown() && !wxIsShiftDown() &&
2686 ((info
->wVKey
== VK_SPACE
) || (info
->wVKey
== VK_RETURN
)) )
2688 wxTreeEvent
event2(wxEVT_COMMAND_TREE_ITEM_ACTIVATED
,
2690 event2
.SetEventObject(this);
2691 if ( !(GetWindowStyle() & wxTR_MULTIPLE
) )
2693 event2
.m_item
= GetSelection();
2695 //else: don't know how to get it
2697 (void)GetEventHandler()->ProcessEvent(event2
);
2702 // NB: MSLU is broken and sends TVN_SELCHANGEDA instead of
2703 // TVN_SELCHANGEDW in Unicode mode under Win98. Therefore
2704 // we have to handle both messages:
2705 case TVN_SELCHANGEDA
:
2706 case TVN_SELCHANGEDW
:
2707 eventType
= wxEVT_COMMAND_TREE_SEL_CHANGED
;
2710 case TVN_SELCHANGINGA
:
2711 case TVN_SELCHANGINGW
:
2713 if ( eventType
== wxEVT_NULL
)
2714 eventType
= wxEVT_COMMAND_TREE_SEL_CHANGING
;
2715 //else: already set above
2717 if (hdr
->code
== TVN_SELCHANGINGW
||
2718 hdr
->code
== TVN_SELCHANGEDW
)
2720 NM_TREEVIEWW
* tv
= (NM_TREEVIEWW
*)lParam
;
2721 event
.m_item
= tv
->itemNew
.hItem
;
2722 event
.m_itemOld
= tv
->itemOld
.hItem
;
2726 NM_TREEVIEWA
* tv
= (NM_TREEVIEWA
*)lParam
;
2727 event
.m_item
= tv
->itemNew
.hItem
;
2728 event
.m_itemOld
= tv
->itemOld
.hItem
;
2733 // instead of explicitly checking for _WIN32_IE, check if the
2734 // required symbols are available in the headers
2735 #if defined(CDDS_PREPAINT) && !wxUSE_COMCTL32_SAFELY
2738 LPNMTVCUSTOMDRAW lptvcd
= (LPNMTVCUSTOMDRAW
)lParam
;
2739 NMCUSTOMDRAW
& nmcd
= lptvcd
->nmcd
;
2740 switch ( nmcd
.dwDrawStage
)
2743 // if we've got any items with non standard attributes,
2744 // notify us before painting each item
2745 *result
= m_hasAnyAttr
? CDRF_NOTIFYITEMDRAW
2749 case CDDS_ITEMPREPAINT
:
2751 wxMapTreeAttr::iterator
2752 it
= m_attrs
.find((void *)nmcd
.dwItemSpec
);
2754 if ( it
== m_attrs
.end() )
2756 // nothing to do for this item
2757 *result
= CDRF_DODEFAULT
;
2761 wxTreeItemAttr
* const attr
= it
->second
;
2763 // selection colours should override ours,
2764 // otherwise it is too confusing ot the user
2765 if ( !(nmcd
.uItemState
& CDIS_SELECTED
) )
2768 if ( attr
->HasBackgroundColour() )
2770 colBack
= attr
->GetBackgroundColour();
2771 lptvcd
->clrTextBk
= wxColourToRGB(colBack
);
2775 // but we still want to keep the special foreground
2776 // colour when we don't have focus (we can't keep
2777 // it when we do, it would usually be unreadable on
2778 // the almost inverted bg colour...)
2779 if ( !(nmcd
.uItemState
& CDIS_SELECTED
) ||
2780 FindFocus() != this )
2783 if ( attr
->HasTextColour() )
2785 colText
= attr
->GetTextColour();
2786 lptvcd
->clrText
= wxColourToRGB(colText
);
2790 if ( attr
->HasFont() )
2792 HFONT hFont
= GetHfontOf(attr
->GetFont());
2794 ::SelectObject(nmcd
.hdc
, hFont
);
2796 *result
= CDRF_NEWFONT
;
2798 else // no specific font
2800 *result
= CDRF_DODEFAULT
;
2806 *result
= CDRF_DODEFAULT
;
2810 // we always process it
2812 #endif // have owner drawn support in headers
2816 DWORD pos
= GetMessagePos();
2818 point
.x
= LOWORD(pos
);
2819 point
.y
= HIWORD(pos
);
2820 ::MapWindowPoints(HWND_DESKTOP
, GetHwnd(), &point
, 1);
2822 wxTreeItemId item
= HitTest(wxPoint(point
.x
, point
.y
), flags
);
2823 if (flags
& wxTREE_HITTEST_ONITEMSTATEICON
)
2825 event
.m_item
= item
;
2826 eventType
= wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK
;
2834 TV_HITTESTINFO tvhti
;
2835 ::GetCursorPos(&tvhti
.pt
);
2836 ::ScreenToClient(GetHwnd(), &tvhti
.pt
);
2837 if ( TreeView_HitTest(GetHwnd(), &tvhti
) )
2839 if ( tvhti
.flags
& TVHT_ONITEM
)
2841 event
.m_item
= tvhti
.hItem
;
2842 eventType
= (int)hdr
->code
== NM_DBLCLK
2843 ? wxEVT_COMMAND_TREE_ITEM_ACTIVATED
2844 : wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK
;
2846 event
.m_pointDrag
.x
= tvhti
.pt
.x
;
2847 event
.m_pointDrag
.y
= tvhti
.pt
.y
;
2856 return wxControl::MSWOnNotify(idCtrl
, lParam
, result
);
2859 event
.SetEventObject(this);
2860 event
.SetEventType(eventType
);
2862 bool processed
= GetEventHandler()->ProcessEvent(event
);
2865 switch ( hdr
->code
)
2868 // we translate NM_DBLCLK into ACTIVATED event, so don't interpret
2869 // the return code of this event handler as the return value for
2870 // NM_DBLCLK - otherwise, double clicking the item to toggle its
2871 // expanded status would never work
2876 case TVN_BEGINRDRAG
:
2877 if ( event
.IsAllowed() )
2879 // normally this is impossible because the m_dragImage is
2880 // deleted once the drag operation is over
2881 wxASSERT_MSG( !m_dragImage
, _T("starting to drag once again?") );
2883 m_dragImage
= new wxDragImage(*this, event
.m_item
);
2884 m_dragImage
->BeginDrag(wxPoint(0, 0), this);
2885 m_dragImage
->Show();
2889 case TVN_DELETEITEM
:
2891 // NB: we might process this message using wxWidgets event
2892 // tables, but due to overhead of wxWin event system we
2893 // prefer to do it here ourself (otherwise deleting a tree
2894 // with many items is just too slow)
2895 NM_TREEVIEW
* tv
= (NM_TREEVIEW
*)lParam
;
2897 wxTreeItemId item
= event
.m_item
;
2898 if ( HasIndirectData(item
) )
2900 wxTreeItemIndirectData
*data
= (wxTreeItemIndirectData
*)
2902 delete data
; // can't be NULL here
2906 wxTreeItemData
*data
= (wxTreeItemData
*)tv
->itemOld
.lParam
;
2907 delete data
; // may be NULL, ok
2910 processed
= true; // Make sure we don't get called twice
2914 case TVN_BEGINLABELEDIT
:
2915 // return true to cancel label editing
2916 *result
= !event
.IsAllowed();
2917 // set ES_WANTRETURN ( like we do in BeginLabelEdit )
2918 if(event
.IsAllowed())
2920 HWND hText
= TreeView_GetEditControl(GetHwnd());
2923 // MBN: if m_textCtrl already has an HWND, it is a stale
2924 // pointer from a previous edit (because the user
2925 // didn't modify the label before dismissing the control,
2926 // and TVN_ENDLABELEDIT was not sent), so delete it
2927 if(m_textCtrl
&& m_textCtrl
->GetHWND() != 0)
2930 m_textCtrl
= new wxTextCtrl();
2931 m_textCtrl
->SetParent(this);
2932 m_textCtrl
->SetHWND((WXHWND
)hText
);
2933 m_textCtrl
->SubclassWin((WXHWND
)hText
);
2935 // set wxTE_PROCESS_ENTER style for the text control to
2936 // force it to process the Enter presses itself, otherwise
2937 // they could be stolen from it by the dialog
2939 m_textCtrl
->SetWindowStyle(m_textCtrl
->GetWindowStyle()
2940 | wxTE_PROCESS_ENTER
);
2945 case TVN_ENDLABELEDIT
:
2946 // return true to set the label to the new string: note that we
2947 // also must pretend that we did process the message or it is going
2948 // to be passed to DefWindowProc() which will happily return false
2949 // cancelling the label change
2950 *result
= event
.IsAllowed();
2953 // ensure that we don't have the text ctrl which is going to be
2959 case TVN_GETINFOTIP
:
2961 // If the user permitted a tooltip change, change it
2962 if (event
.IsAllowed())
2964 SetToolTip(event
.m_label
);
2970 case TVN_SELCHANGING
:
2971 case TVN_ITEMEXPANDING
:
2972 // return true to prevent the action from happening
2973 *result
= !event
.IsAllowed();
2976 case TVN_ITEMEXPANDED
:
2977 // the item is not refreshed properly after expansion when it has
2978 // an image depending on the expanded/collapsed state - bug in
2979 // comctl32.dll or our code?
2981 NM_TREEVIEW
* tv
= (NM_TREEVIEW
*)lParam
;
2982 wxTreeItemId
id(tv
->itemNew
.hItem
);
2984 int image
= GetItemImage(id
, wxTreeItemIcon_Expanded
);
2992 case TVN_GETDISPINFO
:
2993 // NB: so far the user can't set the image himself anyhow, so do it
2994 // anyway - but this may change later
2995 //if ( /* !processed && */ 1 )
2997 wxTreeItemId item
= event
.m_item
;
2998 TV_DISPINFO
*info
= (TV_DISPINFO
*)lParam
;
2999 if ( info
->item
.mask
& TVIF_IMAGE
)
3002 DoGetItemImageFromData
3005 IsExpanded(item
) ? wxTreeItemIcon_Expanded
3006 : wxTreeItemIcon_Normal
3009 if ( info
->item
.mask
& TVIF_SELECTEDIMAGE
)
3011 info
->item
.iSelectedImage
=
3012 DoGetItemImageFromData
3015 IsExpanded(item
) ? wxTreeItemIcon_SelectedExpanded
3016 : wxTreeItemIcon_Selected
3023 // for the other messages the return value is ignored and there is
3024 // nothing special to do
3029 // ----------------------------------------------------------------------------
3031 // ----------------------------------------------------------------------------
3033 // why do they define INDEXTOSTATEIMAGEMASK but not the inverse?
3034 #define STATEIMAGEMASKTOINDEX(state) (((state) & TVIS_STATEIMAGEMASK) >> 12)
3036 void wxTreeCtrl::SetState(const wxTreeItemId
& node
, int state
)
3039 tvi
.hItem
= (HTREEITEM
)node
.m_pItem
;
3040 tvi
.mask
= TVIF_STATE
;
3041 tvi
.stateMask
= TVIS_STATEIMAGEMASK
;
3043 // Select the specified state, or -1 == cycle to the next one.
3046 TreeView_GetItem(GetHwnd(), &tvi
);
3048 state
= STATEIMAGEMASKTOINDEX(tvi
.state
) + 1;
3049 if ( state
== m_imageListState
->GetImageCount() )
3053 wxCHECK_RET( state
< m_imageListState
->GetImageCount(),
3054 _T("wxTreeCtrl::SetState(): item index out of bounds") );
3056 tvi
.state
= INDEXTOSTATEIMAGEMASK(state
);
3058 TreeView_SetItem(GetHwnd(), &tvi
);
3061 int wxTreeCtrl::GetState(const wxTreeItemId
& node
)
3064 tvi
.hItem
= (HTREEITEM
)node
.m_pItem
;
3065 tvi
.mask
= TVIF_STATE
;
3066 tvi
.stateMask
= TVIS_STATEIMAGEMASK
;
3067 TreeView_GetItem(GetHwnd(), &tvi
);
3069 return STATEIMAGEMASKTOINDEX(tvi
.state
);
3072 #if WXWIN_COMPATIBILITY_2_2
3074 wxTreeItemId
wxTreeCtrl::GetParent(const wxTreeItemId
& item
) const
3076 return GetItemParent( item
);
3079 #endif // WXWIN_COMPATIBILITY_2_2
3081 #endif // wxUSE_TREECTRL