1 /////////////////////////////////////////////////////////////////////////////
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 #pragma implementation "treectrl.h"
23 // For compilers that support precompilation, includes "wx.h".
24 #include "wx/wxprec.h"
30 #include "wx/msw/private.h"
32 // Set this to 1 to be _absolutely_ sure that repainting will work for all comctl32.dll versions
33 #define wxUSE_COMCTL32_SAFELY 0
35 // Mingw32 is a bit mental even though this is done in winundef
44 #if defined(__WIN95__)
47 #include "wx/dynarray.h"
48 #include "wx/imaglist.h"
49 #include "wx/treectrl.h"
50 #include "wx/settings.h"
52 #include "wx/msw/dragimag.h"
54 #ifdef __GNUWIN32_OLD__
55 #include "wx/msw/gnuwin32/extra.h"
58 #if defined(__WIN95__) && !(defined(__GNUWIN32_OLD__) || defined(__TWIN32__))
62 // Bug in headers, sometimes
64 #define TVIS_FOCUSED 0x0001
68 #define TV_FIRST 0x1100
71 #ifndef TVS_CHECKBOXES
72 #define TVS_CHECKBOXES 0x0100
75 // old headers might miss these messages (comctl32.dll 4.71+ only)
76 #ifndef TVM_SETBKCOLOR
77 #define TVM_SETBKCOLOR (TV_FIRST + 29)
78 #define TVM_SETTEXTCOLOR (TV_FIRST + 30)
81 // a macro to hide the ugliness of nested casts
82 #define HITEM(item) (HTREEITEM)(WXHTREEITEM)(item)
84 // the native control doesn't support multiple selections under MSW and we
85 // have 2 ways to emulate them: either using TVS_CHECKBOXES style and let
86 // checkboxes be the selection status (checked == selected) or by really
87 // emulating everything, i.e. intercepting mouse and key events &c. The first
88 // approach is much easier but doesn't work with comctl32.dll < 4.71 and also
90 #define wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE 0
92 // ----------------------------------------------------------------------------
94 // ----------------------------------------------------------------------------
96 // wrapper for TreeView_HitTest
97 static HTREEITEM
GetItemFromPoint(HWND hwndTV
, int x
, int y
)
103 return (HTREEITEM
)TreeView_HitTest(hwndTV
, &tvht
);
106 #if !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
108 // wrappers for TreeView_GetItem/TreeView_SetItem
109 static bool IsItemSelected(HWND hwndTV
, HTREEITEM hItem
)
112 tvi
.mask
= TVIF_STATE
| TVIF_HANDLE
;
113 tvi
.stateMask
= TVIS_SELECTED
;
116 if ( !TreeView_GetItem(hwndTV
, &tvi
) )
118 wxLogLastError(wxT("TreeView_GetItem"));
121 return (tvi
.state
& TVIS_SELECTED
) != 0;
124 static void SelectItem(HWND hwndTV
, HTREEITEM hItem
, bool select
= TRUE
)
127 tvi
.mask
= TVIF_STATE
| TVIF_HANDLE
;
128 tvi
.stateMask
= TVIS_SELECTED
;
129 tvi
.state
= select
? TVIS_SELECTED
: 0;
132 if ( TreeView_SetItem(hwndTV
, &tvi
) == -1 )
134 wxLogLastError(wxT("TreeView_SetItem"));
138 static inline void UnselectItem(HWND hwndTV
, HTREEITEM htItem
)
140 SelectItem(hwndTV
, htItem
, FALSE
);
143 static inline void ToggleItemSelection(HWND hwndTV
, HTREEITEM htItem
)
145 SelectItem(hwndTV
, htItem
, !IsItemSelected(hwndTV
, htItem
));
148 // helper function which selects all items in a range and, optionally,
149 // unselects all others
150 static void SelectRange(HWND hwndTV
,
153 bool unselectOthers
= TRUE
)
155 // find the first (or last) item and select it
157 HTREEITEM htItem
= (HTREEITEM
)TreeView_GetRoot(hwndTV
);
158 while ( htItem
&& cont
)
160 if ( (htItem
== htFirst
) || (htItem
== htLast
) )
162 if ( !IsItemSelected(hwndTV
, htItem
) )
164 SelectItem(hwndTV
, htItem
);
171 if ( unselectOthers
&& IsItemSelected(hwndTV
, htItem
) )
173 UnselectItem(hwndTV
, htItem
);
177 htItem
= (HTREEITEM
)TreeView_GetNextVisible(hwndTV
, htItem
);
180 // select the items in range
181 cont
= htFirst
!= htLast
;
182 while ( htItem
&& cont
)
184 if ( !IsItemSelected(hwndTV
, htItem
) )
186 SelectItem(hwndTV
, htItem
);
189 cont
= (htItem
!= htFirst
) && (htItem
!= htLast
);
191 htItem
= (HTREEITEM
)TreeView_GetNextVisible(hwndTV
, htItem
);
195 if ( unselectOthers
)
199 if ( IsItemSelected(hwndTV
, htItem
) )
201 UnselectItem(hwndTV
, htItem
);
204 htItem
= (HTREEITEM
)TreeView_GetNextVisible(hwndTV
, htItem
);
208 // seems to be necessary - otherwise the just selected items don't always
209 // appear as selected
210 UpdateWindow(hwndTV
);
213 // helper function which tricks the standard control into changing the focused
214 // item without changing anything else (if someone knows why Microsoft doesn't
215 // allow to do it by just setting TVIS_FOCUSED flag, please tell me!)
216 static void SetFocus(HWND hwndTV
, HTREEITEM htItem
)
219 HTREEITEM htFocus
= (HTREEITEM
)TreeView_GetSelection(hwndTV
);
224 if ( htItem
!= htFocus
)
226 // remember the selection state of the item
227 bool wasSelected
= IsItemSelected(hwndTV
, htItem
);
229 if ( htFocus
&& IsItemSelected(hwndTV
, htFocus
) )
231 // prevent the tree from unselecting the old focus which it
232 // would do by default (TreeView_SelectItem unselects the
234 TreeView_SelectItem(hwndTV
, 0);
235 SelectItem(hwndTV
, htFocus
);
238 TreeView_SelectItem(hwndTV
, htItem
);
242 // need to clear the selection which TreeView_SelectItem() gave
244 UnselectItem(hwndTV
, htItem
);
246 //else: was selected, still selected - ok
248 //else: nothing to do, focus already there
254 bool wasFocusSelected
= IsItemSelected(hwndTV
, htFocus
);
256 // just clear the focus
257 TreeView_SelectItem(hwndTV
, 0);
259 if ( wasFocusSelected
)
261 // restore the selection state
262 SelectItem(hwndTV
, htFocus
);
265 //else: nothing to do, no focus already
269 #endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
271 // ----------------------------------------------------------------------------
273 // ----------------------------------------------------------------------------
275 // a convenient wrapper around TV_ITEM struct which adds a ctor
277 #pragma warning( disable : 4097 ) // inheriting from typedef
280 struct wxTreeViewItem
: public TV_ITEM
282 wxTreeViewItem(const wxTreeItemId
& item
, // the item handle
283 UINT mask_
, // fields which are valid
284 UINT stateMask_
= 0) // for TVIF_STATE only
286 // hItem member is always valid
287 mask
= mask_
| TVIF_HANDLE
;
288 stateMask
= stateMask_
;
294 #pragma warning( default : 4097 )
297 // a class which encapsulates the tree traversal logic: it vists all (unless
298 // OnVisit() returns FALSE) items under the given one
299 class wxTreeTraversal
302 wxTreeTraversal(const wxTreeCtrl
*tree
)
307 // do traverse the tree: visit all items (recursively by default) under the
308 // given one; return TRUE if all items were traversed or FALSE if the
309 // traversal was aborted because OnVisit returned FALSE
310 bool DoTraverse(const wxTreeItemId
& root
, bool recursively
= TRUE
);
312 // override this function to do whatever is needed for each item, return
313 // FALSE to stop traversing
314 virtual bool OnVisit(const wxTreeItemId
& item
) = 0;
317 const wxTreeCtrl
*GetTree() const { return m_tree
; }
320 bool Traverse(const wxTreeItemId
& root
, bool recursively
);
322 const wxTreeCtrl
*m_tree
;
325 // internal class for getting the selected items
326 class TraverseSelections
: public wxTreeTraversal
329 TraverseSelections(const wxTreeCtrl
*tree
,
330 wxArrayTreeItemIds
& selections
)
331 : wxTreeTraversal(tree
), m_selections(selections
)
333 m_selections
.Empty();
335 DoTraverse(tree
->GetRootItem());
338 virtual bool OnVisit(const wxTreeItemId
& item
)
340 #if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
341 if ( GetTree()->IsItemChecked(item
) )
343 if ( ::IsItemSelected(GetHwndOf(GetTree()), HITEM(item
)) )
346 m_selections
.Add(item
);
352 size_t GetCount() const { return m_selections
.GetCount(); }
355 wxArrayTreeItemIds
& m_selections
;
358 // internal class for counting tree items
359 class TraverseCounter
: public wxTreeTraversal
362 TraverseCounter(const wxTreeCtrl
*tree
,
363 const wxTreeItemId
& root
,
365 : wxTreeTraversal(tree
)
369 DoTraverse(root
, recursively
);
372 virtual bool OnVisit(const wxTreeItemId
& item
)
379 size_t GetCount() const { return m_count
; }
385 // ----------------------------------------------------------------------------
386 // This class is needed for support of different images: the Win32 common
387 // control natively supports only 2 images (the normal one and another for the
388 // selected state). We wish to provide support for 2 more of them for folder
389 // items (i.e. those which have children): for expanded state and for expanded
390 // selected state. For this we use this structure to store the additional items
393 // There is only one problem with this: when we retrieve the item's data, we
394 // don't know whether we get a pointer to wxTreeItemData or
395 // wxTreeItemIndirectData. So we have to maintain a list of all items which
396 // have indirect data inside the listctrl itself.
397 // ----------------------------------------------------------------------------
399 class wxTreeItemIndirectData
402 // ctor associates this data with the item and the real item data becomes
403 // available through our GetData() method
404 wxTreeItemIndirectData(wxTreeCtrl
*tree
, const wxTreeItemId
& item
)
406 for ( size_t n
= 0; n
< WXSIZEOF(m_images
); n
++ )
412 m_data
= tree
->GetItemData(item
);
414 // and set ourselves as the new one
415 tree
->SetIndirectItemData(item
, this);
418 // dtor deletes the associated data as well
419 ~wxTreeItemIndirectData() { delete m_data
; }
422 // get the real data associated with the item
423 wxTreeItemData
*GetData() const { return m_data
; }
425 void SetData(wxTreeItemData
*data
) { m_data
= data
; }
427 // do we have such image?
428 bool HasImage(wxTreeItemIcon which
) const { return m_images
[which
] != -1; }
430 int GetImage(wxTreeItemIcon which
) const { return m_images
[which
]; }
432 void SetImage(int image
, wxTreeItemIcon which
) { m_images
[which
] = image
; }
435 // all the images associated with the item
436 int m_images
[wxTreeItemIcon_Max
];
438 wxTreeItemData
*m_data
;
441 // ----------------------------------------------------------------------------
443 // ----------------------------------------------------------------------------
445 IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl
, wxControl
)
447 // ----------------------------------------------------------------------------
449 // ----------------------------------------------------------------------------
451 // handy table for sending events
452 static const wxEventType g_events
[2][2] =
454 { wxEVT_COMMAND_TREE_ITEM_COLLAPSED
, wxEVT_COMMAND_TREE_ITEM_COLLAPSING
},
455 { wxEVT_COMMAND_TREE_ITEM_EXPANDED
, wxEVT_COMMAND_TREE_ITEM_EXPANDING
}
458 // ============================================================================
460 // ============================================================================
462 // ----------------------------------------------------------------------------
464 // ----------------------------------------------------------------------------
466 bool wxTreeTraversal::DoTraverse(const wxTreeItemId
& root
, bool recursively
)
468 if ( !OnVisit(root
) )
471 return Traverse(root
, recursively
);
474 bool wxTreeTraversal::Traverse(const wxTreeItemId
& root
, bool recursively
)
477 wxTreeItemId child
= m_tree
->GetFirstChild(root
, cookie
);
478 while ( child
.IsOk() )
480 // depth first traversal
481 if ( recursively
&& !Traverse(child
, TRUE
) )
484 if ( !OnVisit(child
) )
487 child
= m_tree
->GetNextChild(root
, cookie
);
493 // ----------------------------------------------------------------------------
494 // construction and destruction
495 // ----------------------------------------------------------------------------
497 void wxTreeCtrl::Init()
499 m_imageListNormal
= NULL
;
500 m_imageListState
= NULL
;
502 m_hasAnyAttr
= FALSE
;
508 bool wxTreeCtrl::Create(wxWindow
*parent
,
513 const wxValidator
& validator
,
514 const wxString
& name
)
518 if ( !CreateControl(parent
, id
, pos
, size
, style
, validator
, name
) )
521 DWORD wstyle
= WS_VISIBLE
| WS_CHILD
| WS_TABSTOP
|
522 TVS_SHOWSELALWAYS
/* | WS_CLIPSIBLINGS */;
524 if ((m_windowStyle
& wxTR_NO_LINES
) == 0)
525 wstyle
|= TVS_HASLINES
;
526 if ( m_windowStyle
& wxTR_HAS_BUTTONS
)
527 wstyle
|= TVS_HASBUTTONS
;
529 if ( m_windowStyle
& wxTR_EDIT_LABELS
)
530 wstyle
|= TVS_EDITLABELS
;
532 if ( m_windowStyle
& wxTR_LINES_AT_ROOT
)
533 wstyle
|= TVS_LINESATROOT
;
535 // using TVS_CHECKBOXES for emulation of a multiselection tree control
536 // doesn't work without the new enough headers
537 #if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE && \
538 !defined( __GNUWIN32_OLD__ ) && \
539 !defined( __BORLANDC__ ) && \
540 !defined( __WATCOMC__ ) && \
541 (!defined(__VISUALC__) || (__VISUALC__ > 1010))
543 // we emulate the multiple selection tree controls by using checkboxes: set
544 // up the image list we need for this if we do have multiple selections
545 if ( m_windowStyle
& wxTR_MULTIPLE
)
546 wstyle
|= TVS_CHECKBOXES
;
547 #endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
549 // Create the tree control.
550 if ( !MSWCreateControl(WC_TREEVIEW
, wstyle
) )
553 #if wxUSE_COMCTL32_SAFELY
554 wxWindow::SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW
));
555 wxWindow::SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
557 SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW
));
558 SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
560 // This works around a bug in the Windows tree control whereby for some versions
561 // of comctrl32, setting any colour actually draws the background in black.
562 // This will initialise the background to the system colour.
563 // THIS FIX NOW REVERTED since it caused problems on _other_ systems.
564 // Assume the user has an updated comctl32.dll.
565 ::SendMessage(GetHwnd(), TVM_SETBKCOLOR
, 0,-1);
566 wxWindow::SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW
));
567 SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
571 // VZ: this is some experimental code which may be used to get the
572 // TVS_CHECKBOXES style functionality for comctl32.dll < 4.71.
573 // AFAIK, the standard DLL does about the same thing anyhow.
575 if ( m_windowStyle
& wxTR_MULTIPLE
)
579 // create the DC compatible with the current screen
580 HDC hdcMem
= CreateCompatibleDC(NULL
);
582 // create a mono bitmap of the standard size
583 int x
= GetSystemMetrics(SM_CXMENUCHECK
);
584 int y
= GetSystemMetrics(SM_CYMENUCHECK
);
585 wxImageList
imagelistCheckboxes(x
, y
, FALSE
, 2);
586 HBITMAP hbmpCheck
= CreateBitmap(x
, y
, // bitmap size
587 1, // # of color planes
588 1, // # bits needed for one pixel
589 0); // array containing colour data
590 SelectObject(hdcMem
, hbmpCheck
);
592 // then draw a check mark into it
593 RECT rect
= { 0, 0, x
, y
};
594 if ( !::DrawFrameControl(hdcMem
, &rect
,
596 DFCS_BUTTONCHECK
| DFCS_CHECKED
) )
598 wxLogLastError(wxT("DrawFrameControl(check)"));
601 bmp
.SetHBITMAP((WXHBITMAP
)hbmpCheck
);
602 imagelistCheckboxes
.Add(bmp
);
604 if ( !::DrawFrameControl(hdcMem
, &rect
,
608 wxLogLastError(wxT("DrawFrameControl(uncheck)"));
611 bmp
.SetHBITMAP((WXHBITMAP
)hbmpCheck
);
612 imagelistCheckboxes
.Add(bmp
);
618 SetStateImageList(&imagelistCheckboxes
);
622 SetSize(pos
.x
, pos
.y
, size
.x
, size
.y
);
627 wxTreeCtrl::~wxTreeCtrl()
629 // delete any attributes
632 for ( wxNode
*node
= m_attrs
.Next(); node
; node
= m_attrs
.Next() )
634 delete (wxTreeItemAttr
*)node
->Data();
637 // prevent TVN_DELETEITEM handler from deleting the attributes again!
638 m_hasAnyAttr
= FALSE
;
643 // delete user data to prevent memory leaks
647 // ----------------------------------------------------------------------------
649 // ----------------------------------------------------------------------------
651 // simple wrappers which add error checking in debug mode
653 bool wxTreeCtrl::DoGetItem(wxTreeViewItem
* tvItem
) const
655 if ( !TreeView_GetItem(GetHwnd(), tvItem
) )
657 wxLogLastError(wxT("TreeView_GetItem"));
665 void wxTreeCtrl::DoSetItem(wxTreeViewItem
* tvItem
)
667 if ( TreeView_SetItem(GetHwnd(), tvItem
) == -1 )
669 wxLogLastError(wxT("TreeView_SetItem"));
673 size_t wxTreeCtrl::GetCount() const
675 return (size_t)TreeView_GetCount(GetHwnd());
678 unsigned int wxTreeCtrl::GetIndent() const
680 return TreeView_GetIndent(GetHwnd());
683 void wxTreeCtrl::SetIndent(unsigned int indent
)
685 TreeView_SetIndent(GetHwnd(), indent
);
688 wxImageList
*wxTreeCtrl::GetImageList() const
690 return m_imageListNormal
;
693 wxImageList
*wxTreeCtrl::GetStateImageList() const
695 return m_imageListNormal
;
698 void wxTreeCtrl::SetAnyImageList(wxImageList
*imageList
, int which
)
701 TreeView_SetImageList(GetHwnd(),
702 imageList
? imageList
->GetHIMAGELIST() : 0,
706 void wxTreeCtrl::SetImageList(wxImageList
*imageList
)
708 SetAnyImageList(m_imageListNormal
= imageList
, TVSIL_NORMAL
);
711 void wxTreeCtrl::SetStateImageList(wxImageList
*imageList
)
713 SetAnyImageList(m_imageListState
= imageList
, TVSIL_STATE
);
716 size_t wxTreeCtrl::GetChildrenCount(const wxTreeItemId
& item
,
717 bool recursively
) const
719 TraverseCounter
counter(this, item
, recursively
);
721 return counter
.GetCount() - 1;
724 // ----------------------------------------------------------------------------
726 // ----------------------------------------------------------------------------
728 bool wxTreeCtrl::SetBackgroundColour(const wxColour
&colour
)
730 #if !wxUSE_COMCTL32_SAFELY
731 if ( !wxWindowBase::SetBackgroundColour(colour
) )
734 SendMessage(GetHwnd(), TVM_SETBKCOLOR
, 0, colour
.GetPixel());
740 bool wxTreeCtrl::SetForegroundColour(const wxColour
&colour
)
742 #if !wxUSE_COMCTL32_SAFELY
743 if ( !wxWindowBase::SetForegroundColour(colour
) )
746 SendMessage(GetHwnd(), TVM_SETTEXTCOLOR
, 0, colour
.GetPixel());
752 // ----------------------------------------------------------------------------
754 // ----------------------------------------------------------------------------
756 wxString
wxTreeCtrl::GetItemText(const wxTreeItemId
& item
) const
758 wxChar buf
[512]; // the size is arbitrary...
760 wxTreeViewItem
tvItem(item
, TVIF_TEXT
);
761 tvItem
.pszText
= buf
;
762 tvItem
.cchTextMax
= WXSIZEOF(buf
);
763 if ( !DoGetItem(&tvItem
) )
765 // don't return some garbage which was on stack, but an empty string
769 return wxString(buf
);
772 void wxTreeCtrl::SetItemText(const wxTreeItemId
& item
, const wxString
& text
)
774 wxTreeViewItem
tvItem(item
, TVIF_TEXT
);
775 tvItem
.pszText
= (wxChar
*)text
.c_str(); // conversion is ok
779 int wxTreeCtrl::DoGetItemImageFromData(const wxTreeItemId
& item
,
780 wxTreeItemIcon which
) const
782 wxTreeViewItem
tvItem(item
, TVIF_PARAM
);
783 if ( !DoGetItem(&tvItem
) )
788 return ((wxTreeItemIndirectData
*)tvItem
.lParam
)->GetImage(which
);
791 void wxTreeCtrl::DoSetItemImageFromData(const wxTreeItemId
& item
,
793 wxTreeItemIcon which
) const
795 wxTreeViewItem
tvItem(item
, TVIF_PARAM
);
796 if ( !DoGetItem(&tvItem
) )
801 wxTreeItemIndirectData
*data
= ((wxTreeItemIndirectData
*)tvItem
.lParam
);
803 data
->SetImage(image
, which
);
805 // make sure that we have selected images as well
806 if ( which
== wxTreeItemIcon_Normal
&&
807 !data
->HasImage(wxTreeItemIcon_Selected
) )
809 data
->SetImage(image
, wxTreeItemIcon_Selected
);
812 if ( which
== wxTreeItemIcon_Expanded
&&
813 !data
->HasImage(wxTreeItemIcon_SelectedExpanded
) )
815 data
->SetImage(image
, wxTreeItemIcon_SelectedExpanded
);
819 void wxTreeCtrl::DoSetItemImages(const wxTreeItemId
& item
,
823 wxTreeViewItem
tvItem(item
, TVIF_IMAGE
| TVIF_SELECTEDIMAGE
);
824 tvItem
.iSelectedImage
= imageSel
;
825 tvItem
.iImage
= image
;
829 int wxTreeCtrl::GetItemImage(const wxTreeItemId
& item
,
830 wxTreeItemIcon which
) const
832 if ( HasIndirectData(item
) )
834 return DoGetItemImageFromData(item
, which
);
841 wxFAIL_MSG( wxT("unknown tree item image type") );
843 case wxTreeItemIcon_Normal
:
847 case wxTreeItemIcon_Selected
:
848 mask
= TVIF_SELECTEDIMAGE
;
851 case wxTreeItemIcon_Expanded
:
852 case wxTreeItemIcon_SelectedExpanded
:
856 wxTreeViewItem
tvItem(item
, mask
);
859 return mask
== TVIF_IMAGE
? tvItem
.iImage
: tvItem
.iSelectedImage
;
862 void wxTreeCtrl::SetItemImage(const wxTreeItemId
& item
, int image
,
863 wxTreeItemIcon which
)
865 int imageNormal
, imageSel
;
869 wxFAIL_MSG( wxT("unknown tree item image type") );
871 case wxTreeItemIcon_Normal
:
873 imageSel
= GetItemSelectedImage(item
);
876 case wxTreeItemIcon_Selected
:
877 imageNormal
= GetItemImage(item
);
881 case wxTreeItemIcon_Expanded
:
882 case wxTreeItemIcon_SelectedExpanded
:
883 if ( !HasIndirectData(item
) )
885 // we need to get the old images first, because after we create
886 // the wxTreeItemIndirectData GetItemXXXImage() will use it to
888 imageNormal
= GetItemImage(item
);
889 imageSel
= GetItemSelectedImage(item
);
891 // if it doesn't have it yet, add it
892 wxTreeItemIndirectData
*data
= new
893 wxTreeItemIndirectData(this, item
);
895 // copy the data to the new location
896 data
->SetImage(imageNormal
, wxTreeItemIcon_Normal
);
897 data
->SetImage(imageSel
, wxTreeItemIcon_Selected
);
900 DoSetItemImageFromData(item
, image
, which
);
902 // reset the normal/selected images because we won't use them any
903 // more - now they're stored inside the indirect data
905 imageSel
= I_IMAGECALLBACK
;
909 // NB: at least in version 5.00.0518.9 of comctl32.dll we need to always
910 // change both normal and selected image - otherwise the change simply
911 // doesn't take place!
912 DoSetItemImages(item
, imageNormal
, imageSel
);
915 wxTreeItemData
*wxTreeCtrl::GetItemData(const wxTreeItemId
& item
) const
917 wxTreeViewItem
tvItem(item
, TVIF_PARAM
);
918 if ( !DoGetItem(&tvItem
) )
923 if ( HasIndirectData(item
) )
925 return ((wxTreeItemIndirectData
*)tvItem
.lParam
)->GetData();
929 return (wxTreeItemData
*)tvItem
.lParam
;
933 void wxTreeCtrl::SetItemData(const wxTreeItemId
& item
, wxTreeItemData
*data
)
935 wxTreeViewItem
tvItem(item
, TVIF_PARAM
);
937 if ( HasIndirectData(item
) )
939 if ( DoGetItem(&tvItem
) )
941 ((wxTreeItemIndirectData
*)tvItem
.lParam
)->SetData(data
);
945 wxFAIL_MSG( wxT("failed to change tree items data") );
950 tvItem
.lParam
= (LPARAM
)data
;
955 void wxTreeCtrl::SetIndirectItemData(const wxTreeItemId
& item
,
956 wxTreeItemIndirectData
*data
)
958 // this should never happen because it's unnecessary and will probably lead
959 // to crash too because the code elsewhere supposes that the pointer the
960 // wxTreeItemIndirectData has is a real wxItemData and not
961 // wxTreeItemIndirectData as well
962 wxASSERT_MSG( !HasIndirectData(item
), wxT("setting indirect data twice?") );
964 SetItemData(item
, (wxTreeItemData
*)data
);
966 m_itemsWithIndirectData
.Add(item
);
969 bool wxTreeCtrl::HasIndirectData(const wxTreeItemId
& item
) const
971 return m_itemsWithIndirectData
.Index(item
) != wxNOT_FOUND
;
974 void wxTreeCtrl::SetItemHasChildren(const wxTreeItemId
& item
, bool has
)
976 wxTreeViewItem
tvItem(item
, TVIF_CHILDREN
);
977 tvItem
.cChildren
= (int)has
;
981 void wxTreeCtrl::SetItemBold(const wxTreeItemId
& item
, bool bold
)
983 wxTreeViewItem
tvItem(item
, TVIF_STATE
, TVIS_BOLD
);
984 tvItem
.state
= bold
? TVIS_BOLD
: 0;
988 void wxTreeCtrl::SetItemDropHighlight(const wxTreeItemId
& item
, bool highlight
)
990 wxTreeViewItem
tvItem(item
, TVIF_STATE
, TVIS_DROPHILITED
);
991 tvItem
.state
= highlight
? TVIS_DROPHILITED
: 0;
995 void wxTreeCtrl::SetItemTextColour(const wxTreeItemId
& item
,
1000 long id
= (long)(WXHTREEITEM
)item
;
1001 wxTreeItemAttr
*attr
= (wxTreeItemAttr
*)m_attrs
.Get(id
);
1004 attr
= new wxTreeItemAttr
;
1005 m_attrs
.Put(id
, (wxObject
*)attr
);
1008 attr
->SetTextColour(col
);
1011 void wxTreeCtrl::SetItemBackgroundColour(const wxTreeItemId
& item
,
1012 const wxColour
& col
)
1014 m_hasAnyAttr
= TRUE
;
1016 long id
= (long)(WXHTREEITEM
)item
;
1017 wxTreeItemAttr
*attr
= (wxTreeItemAttr
*)m_attrs
.Get(id
);
1020 attr
= new wxTreeItemAttr
;
1021 m_attrs
.Put(id
, (wxObject
*)attr
);
1024 attr
->SetBackgroundColour(col
);
1027 void wxTreeCtrl::SetItemFont(const wxTreeItemId
& item
, const wxFont
& font
)
1029 m_hasAnyAttr
= TRUE
;
1031 long id
= (long)(WXHTREEITEM
)item
;
1032 wxTreeItemAttr
*attr
= (wxTreeItemAttr
*)m_attrs
.Get(id
);
1035 attr
= new wxTreeItemAttr
;
1036 m_attrs
.Put(id
, (wxObject
*)attr
);
1039 attr
->SetFont(font
);
1042 // ----------------------------------------------------------------------------
1044 // ----------------------------------------------------------------------------
1046 bool wxTreeCtrl::IsVisible(const wxTreeItemId
& item
) const
1048 // Bug in Gnu-Win32 headers, so don't use the macro TreeView_GetItemRect
1051 // this ugliness comes directly from MSDN - it *is* the correct way to pass
1052 // the HTREEITEM with TVM_GETITEMRECT
1053 *(WXHTREEITEM
*)&rect
= (WXHTREEITEM
)item
;
1055 // FALSE means get item rect for the whole item, not only text
1056 return SendMessage(GetHwnd(), TVM_GETITEMRECT
, FALSE
, (LPARAM
)&rect
) != 0;
1060 bool wxTreeCtrl::ItemHasChildren(const wxTreeItemId
& item
) const
1062 wxTreeViewItem
tvItem(item
, TVIF_CHILDREN
);
1065 return tvItem
.cChildren
!= 0;
1068 bool wxTreeCtrl::IsExpanded(const wxTreeItemId
& item
) const
1070 // probably not a good idea to put it here
1071 //wxASSERT( ItemHasChildren(item) );
1073 wxTreeViewItem
tvItem(item
, TVIF_STATE
, TVIS_EXPANDED
);
1076 return (tvItem
.state
& TVIS_EXPANDED
) != 0;
1079 bool wxTreeCtrl::IsSelected(const wxTreeItemId
& item
) const
1081 wxTreeViewItem
tvItem(item
, TVIF_STATE
, TVIS_SELECTED
);
1084 return (tvItem
.state
& TVIS_SELECTED
) != 0;
1087 bool wxTreeCtrl::IsBold(const wxTreeItemId
& item
) const
1089 wxTreeViewItem
tvItem(item
, TVIF_STATE
, TVIS_BOLD
);
1092 return (tvItem
.state
& TVIS_BOLD
) != 0;
1095 // ----------------------------------------------------------------------------
1097 // ----------------------------------------------------------------------------
1099 wxTreeItemId
wxTreeCtrl::GetRootItem() const
1101 return wxTreeItemId((WXHTREEITEM
) TreeView_GetRoot(GetHwnd()));
1104 wxTreeItemId
wxTreeCtrl::GetSelection() const
1106 wxCHECK_MSG( !(m_windowStyle
& wxTR_MULTIPLE
), (WXHTREEITEM
)0,
1107 wxT("this only works with single selection controls") );
1109 return wxTreeItemId((WXHTREEITEM
) TreeView_GetSelection(GetHwnd()));
1112 wxTreeItemId
wxTreeCtrl::GetParent(const wxTreeItemId
& item
) const
1114 return wxTreeItemId((WXHTREEITEM
) TreeView_GetParent(GetHwnd(), HITEM(item
)));
1117 wxTreeItemId
wxTreeCtrl::GetFirstChild(const wxTreeItemId
& item
,
1118 long& _cookie
) const
1120 // remember the last child returned in 'cookie'
1121 _cookie
= (long)TreeView_GetChild(GetHwnd(), HITEM(item
));
1123 return wxTreeItemId((WXHTREEITEM
)_cookie
);
1126 wxTreeItemId
wxTreeCtrl::GetNextChild(const wxTreeItemId
& WXUNUSED(item
),
1127 long& _cookie
) const
1129 wxTreeItemId l
= wxTreeItemId((WXHTREEITEM
)TreeView_GetNextSibling(GetHwnd(),
1136 wxTreeItemId
wxTreeCtrl::GetLastChild(const wxTreeItemId
& item
) const
1138 // can this be done more efficiently?
1141 wxTreeItemId childLast
,
1142 child
= GetFirstChild(item
, cookie
);
1143 while ( child
.IsOk() )
1146 child
= GetNextChild(item
, cookie
);
1152 wxTreeItemId
wxTreeCtrl::GetNextSibling(const wxTreeItemId
& item
) const
1154 return wxTreeItemId((WXHTREEITEM
) TreeView_GetNextSibling(GetHwnd(), HITEM(item
)));
1157 wxTreeItemId
wxTreeCtrl::GetPrevSibling(const wxTreeItemId
& item
) const
1159 return wxTreeItemId((WXHTREEITEM
) TreeView_GetPrevSibling(GetHwnd(), HITEM(item
)));
1162 wxTreeItemId
wxTreeCtrl::GetFirstVisibleItem() const
1164 return wxTreeItemId((WXHTREEITEM
) TreeView_GetFirstVisible(GetHwnd()));
1167 wxTreeItemId
wxTreeCtrl::GetNextVisible(const wxTreeItemId
& item
) const
1169 wxASSERT_MSG( IsVisible(item
), wxT("The item you call GetNextVisible() for must be visible itself!"));
1171 return wxTreeItemId((WXHTREEITEM
) TreeView_GetNextVisible(GetHwnd(), HITEM(item
)));
1174 wxTreeItemId
wxTreeCtrl::GetPrevVisible(const wxTreeItemId
& item
) const
1176 wxASSERT_MSG( IsVisible(item
), wxT("The item you call GetPrevVisible() for must be visible itself!"));
1178 return wxTreeItemId((WXHTREEITEM
) TreeView_GetPrevVisible(GetHwnd(), HITEM(item
)));
1181 // ----------------------------------------------------------------------------
1182 // multiple selections emulation
1183 // ----------------------------------------------------------------------------
1185 bool wxTreeCtrl::IsItemChecked(const wxTreeItemId
& item
) const
1187 // receive the desired information.
1188 wxTreeViewItem
tvItem(item
, TVIF_STATE
, TVIS_STATEIMAGEMASK
);
1191 // state image indices are 1 based
1192 return ((tvItem
.state
>> 12) - 1) == 1;
1195 void wxTreeCtrl::SetItemCheck(const wxTreeItemId
& item
, bool check
)
1197 // receive the desired information.
1198 wxTreeViewItem
tvItem(item
, TVIF_STATE
, TVIS_STATEIMAGEMASK
);
1200 // state images are one-based
1201 tvItem
.state
= (check
? 2 : 1) << 12;
1206 size_t wxTreeCtrl::GetSelections(wxArrayTreeItemIds
& selections
) const
1208 TraverseSelections
selector(this, selections
);
1210 return selector
.GetCount();
1213 // ----------------------------------------------------------------------------
1215 // ----------------------------------------------------------------------------
1217 wxTreeItemId
wxTreeCtrl::DoInsertItem(const wxTreeItemId
& parent
,
1218 wxTreeItemId hInsertAfter
,
1219 const wxString
& text
,
1220 int image
, int selectedImage
,
1221 wxTreeItemData
*data
)
1223 wxCHECK_MSG( parent
.IsOk() || !TreeView_GetRoot(GetHwnd()),
1225 _T("can't have more than one root in the tree") );
1227 TV_INSERTSTRUCT tvIns
;
1228 tvIns
.hParent
= HITEM(parent
);
1229 tvIns
.hInsertAfter
= HITEM(hInsertAfter
);
1231 // this is how we insert the item as the first child: supply a NULL
1233 if ( !tvIns
.hInsertAfter
)
1235 tvIns
.hInsertAfter
= TVI_FIRST
;
1239 if ( !text
.IsEmpty() )
1242 tvIns
.item
.pszText
= (wxChar
*)text
.c_str(); // cast is ok
1246 tvIns
.item
.pszText
= NULL
;
1247 tvIns
.item
.cchTextMax
= 0;
1253 tvIns
.item
.iImage
= image
;
1255 if ( selectedImage
== -1 )
1257 // take the same image for selected icon if not specified
1258 selectedImage
= image
;
1262 if ( selectedImage
!= -1 )
1264 mask
|= TVIF_SELECTEDIMAGE
;
1265 tvIns
.item
.iSelectedImage
= selectedImage
;
1271 tvIns
.item
.lParam
= (LPARAM
)data
;
1274 tvIns
.item
.mask
= mask
;
1276 HTREEITEM id
= (HTREEITEM
) TreeView_InsertItem(GetHwnd(), &tvIns
);
1279 wxLogLastError(wxT("TreeView_InsertItem"));
1284 // associate the application tree item with Win32 tree item handle
1285 data
->SetId((WXHTREEITEM
)id
);
1288 return wxTreeItemId((WXHTREEITEM
)id
);
1291 // for compatibility only
1292 wxTreeItemId
wxTreeCtrl::InsertItem(const wxTreeItemId
& parent
,
1293 const wxString
& text
,
1294 int image
, int selImage
,
1297 return DoInsertItem(parent
, (WXHTREEITEM
)insertAfter
, text
,
1298 image
, selImage
, NULL
);
1301 wxTreeItemId
wxTreeCtrl::AddRoot(const wxString
& text
,
1302 int image
, int selectedImage
,
1303 wxTreeItemData
*data
)
1305 return DoInsertItem(wxTreeItemId((WXHTREEITEM
) 0), (WXHTREEITEM
) 0,
1306 text
, image
, selectedImage
, data
);
1309 wxTreeItemId
wxTreeCtrl::PrependItem(const wxTreeItemId
& parent
,
1310 const wxString
& text
,
1311 int image
, int selectedImage
,
1312 wxTreeItemData
*data
)
1314 return DoInsertItem(parent
, (WXHTREEITEM
) TVI_FIRST
,
1315 text
, image
, selectedImage
, data
);
1318 wxTreeItemId
wxTreeCtrl::InsertItem(const wxTreeItemId
& parent
,
1319 const wxTreeItemId
& idPrevious
,
1320 const wxString
& text
,
1321 int image
, int selectedImage
,
1322 wxTreeItemData
*data
)
1324 return DoInsertItem(parent
, idPrevious
, text
, image
, selectedImage
, data
);
1327 wxTreeItemId
wxTreeCtrl::InsertItem(const wxTreeItemId
& parent
,
1329 const wxString
& text
,
1330 int image
, int selectedImage
,
1331 wxTreeItemData
*data
)
1333 // find the item from index
1335 wxTreeItemId idPrev
, idCur
= GetFirstChild(parent
, cookie
);
1336 while ( index
!= 0 && idCur
.IsOk() )
1341 idCur
= GetNextChild(parent
, cookie
);
1344 // assert, not check: if the index is invalid, we will append the item
1346 wxASSERT_MSG( index
== 0, _T("bad index in wxTreeCtrl::InsertItem") );
1348 return DoInsertItem(parent
, idPrev
, text
, image
, selectedImage
, data
);
1351 wxTreeItemId
wxTreeCtrl::AppendItem(const wxTreeItemId
& parent
,
1352 const wxString
& text
,
1353 int image
, int selectedImage
,
1354 wxTreeItemData
*data
)
1356 return DoInsertItem(parent
, (WXHTREEITEM
) TVI_LAST
,
1357 text
, image
, selectedImage
, data
);
1360 void wxTreeCtrl::Delete(const wxTreeItemId
& item
)
1362 if ( !TreeView_DeleteItem(GetHwnd(), HITEM(item
)) )
1364 wxLogLastError(wxT("TreeView_DeleteItem"));
1368 // delete all children (but don't delete the item itself)
1369 void wxTreeCtrl::DeleteChildren(const wxTreeItemId
& item
)
1373 wxArrayLong children
;
1374 wxTreeItemId child
= GetFirstChild(item
, cookie
);
1375 while ( child
.IsOk() )
1377 children
.Add((long)(WXHTREEITEM
)child
);
1379 child
= GetNextChild(item
, cookie
);
1382 size_t nCount
= children
.Count();
1383 for ( size_t n
= 0; n
< nCount
; n
++ )
1385 if ( !TreeView_DeleteItem(GetHwnd(), (HTREEITEM
)children
[n
]) )
1387 wxLogLastError(wxT("TreeView_DeleteItem"));
1392 void wxTreeCtrl::DeleteAllItems()
1394 if ( !TreeView_DeleteAllItems(GetHwnd()) )
1396 wxLogLastError(wxT("TreeView_DeleteAllItems"));
1400 void wxTreeCtrl::DoExpand(const wxTreeItemId
& item
, int flag
)
1402 wxASSERT_MSG( flag
== TVE_COLLAPSE
||
1403 flag
== (TVE_COLLAPSE
| TVE_COLLAPSERESET
) ||
1404 flag
== TVE_EXPAND
||
1406 wxT("Unknown flag in wxTreeCtrl::DoExpand") );
1408 // TreeView_Expand doesn't send TVN_ITEMEXPAND(ING) messages, so we must
1409 // emulate them. This behaviour has changed slightly with comctl32.dll
1410 // v 4.70 - now it does send them but only the first time. To maintain
1411 // compatible behaviour and also in order to not have surprises with the
1412 // future versions, don't rely on this and still do everything ourselves.
1413 // To avoid that the messages be sent twice when the item is expanded for
1414 // the first time we must clear TVIS_EXPANDEDONCE style manually.
1416 wxTreeViewItem
tvItem(item
, TVIF_STATE
, TVIS_EXPANDEDONCE
);
1420 if ( TreeView_Expand(GetHwnd(), HITEM(item
), flag
) != 0 )
1422 wxTreeEvent
event(wxEVT_NULL
, m_windowId
);
1423 event
.m_item
= item
;
1425 bool isExpanded
= IsExpanded(item
);
1427 event
.SetEventObject(this);
1429 // FIXME return value of {EXPAND|COLLAPS}ING event handler is discarded
1430 event
.SetEventType(g_events
[isExpanded
][TRUE
]);
1431 GetEventHandler()->ProcessEvent(event
);
1433 event
.SetEventType(g_events
[isExpanded
][FALSE
]);
1434 GetEventHandler()->ProcessEvent(event
);
1436 //else: change didn't took place, so do nothing at all
1439 void wxTreeCtrl::Expand(const wxTreeItemId
& item
)
1441 DoExpand(item
, TVE_EXPAND
);
1444 void wxTreeCtrl::Collapse(const wxTreeItemId
& item
)
1446 DoExpand(item
, TVE_COLLAPSE
);
1449 void wxTreeCtrl::CollapseAndReset(const wxTreeItemId
& item
)
1451 DoExpand(item
, TVE_COLLAPSE
| TVE_COLLAPSERESET
);
1454 void wxTreeCtrl::Toggle(const wxTreeItemId
& item
)
1456 DoExpand(item
, TVE_TOGGLE
);
1459 void wxTreeCtrl::ExpandItem(const wxTreeItemId
& item
, int action
)
1461 DoExpand(item
, action
);
1464 void wxTreeCtrl::Unselect()
1466 wxASSERT_MSG( !(m_windowStyle
& wxTR_MULTIPLE
),
1467 wxT("doesn't make sense, may be you want UnselectAll()?") );
1469 // just remove the selection
1470 SelectItem(wxTreeItemId((WXHTREEITEM
) 0));
1473 void wxTreeCtrl::UnselectAll()
1475 if ( m_windowStyle
& wxTR_MULTIPLE
)
1477 wxArrayTreeItemIds selections
;
1478 size_t count
= GetSelections(selections
);
1479 for ( size_t n
= 0; n
< count
; n
++ )
1481 #if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1482 SetItemCheck(selections
[n
], FALSE
);
1483 #else // !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1484 ::UnselectItem(GetHwnd(), HITEM(selections
[n
]));
1485 #endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE/!wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1490 // just remove the selection
1495 void wxTreeCtrl::SelectItem(const wxTreeItemId
& item
)
1497 if ( m_windowStyle
& wxTR_MULTIPLE
)
1499 #if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1500 // selecting the item means checking it
1502 #else // !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1503 ::SelectItem(GetHwnd(), HITEM(item
));
1504 #endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE/!wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1508 // inspite of the docs (MSDN Jan 99 edition), we don't seem to receive
1509 // the notification from the control (i.e. TVN_SELCHANG{ED|ING}), so
1510 // send them ourselves
1512 wxTreeEvent
event(wxEVT_NULL
, m_windowId
);
1513 event
.m_item
= item
;
1514 event
.SetEventObject(this);
1516 event
.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGING
);
1517 if ( !GetEventHandler()->ProcessEvent(event
) || event
.IsAllowed() )
1519 if ( !TreeView_SelectItem(GetHwnd(), HITEM(item
)) )
1521 wxLogLastError(wxT("TreeView_SelectItem"));
1525 event
.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED
);
1526 (void)GetEventHandler()->ProcessEvent(event
);
1529 //else: program vetoed the change
1533 void wxTreeCtrl::EnsureVisible(const wxTreeItemId
& item
)
1536 TreeView_EnsureVisible(GetHwnd(), HITEM(item
));
1539 void wxTreeCtrl::ScrollTo(const wxTreeItemId
& item
)
1541 if ( !TreeView_SelectSetFirstVisible(GetHwnd(), HITEM(item
)) )
1543 wxLogLastError(wxT("TreeView_SelectSetFirstVisible"));
1547 wxTextCtrl
* wxTreeCtrl::GetEditControl() const
1549 // normally, we could try to do something like this to return something
1550 // even when the editing was started by the user and not by calling
1551 // EditLabel() - but as nobody has asked for this so far and there might be
1552 // problems in the code below, I leave it disabled for now (VZ)
1556 HWND hwndText
= TreeView_GetEditControl(GetHwnd());
1559 m_textCtrl
= new wxTextCtrl(this, -1);
1561 m_textCtrl
->SetHWND((WXHWND
)hwndText
);
1563 //else: not editing label right now
1570 void wxTreeCtrl::DeleteTextCtrl()
1574 m_textCtrl
->UnsubclassWin();
1575 m_textCtrl
->SetHWND(0);
1581 wxTextCtrl
* wxTreeCtrl::EditLabel(const wxTreeItemId
& item
,
1582 wxClassInfo
* textControlClass
)
1584 wxASSERT( textControlClass
->IsKindOf(CLASSINFO(wxTextCtrl
)) );
1588 HWND hWnd
= (HWND
) TreeView_EditLabel(GetHwnd(), HITEM(item
));
1590 // this is not an error - the TVN_BEGINLABELEDIT handler might have
1597 m_textCtrl
= (wxTextCtrl
*)textControlClass
->CreateObject();
1598 m_textCtrl
->SetHWND((WXHWND
)hWnd
);
1599 m_textCtrl
->SubclassWin((WXHWND
)hWnd
);
1604 // End label editing, optionally cancelling the edit
1605 void wxTreeCtrl::EndEditLabel(const wxTreeItemId
& item
, bool discardChanges
)
1607 TreeView_EndEditLabelNow(GetHwnd(), discardChanges
);
1612 wxTreeItemId
wxTreeCtrl::HitTest(const wxPoint
& point
, int& flags
)
1614 TV_HITTESTINFO hitTestInfo
;
1615 hitTestInfo
.pt
.x
= (int)point
.x
;
1616 hitTestInfo
.pt
.y
= (int)point
.y
;
1618 TreeView_HitTest(GetHwnd(), &hitTestInfo
);
1623 #define TRANSLATE_FLAG(flag) if ( hitTestInfo.flags & TVHT_##flag ) \
1624 flags |= wxTREE_HITTEST_##flag
1626 TRANSLATE_FLAG(ABOVE
);
1627 TRANSLATE_FLAG(BELOW
);
1628 TRANSLATE_FLAG(NOWHERE
);
1629 TRANSLATE_FLAG(ONITEMBUTTON
);
1630 TRANSLATE_FLAG(ONITEMICON
);
1631 TRANSLATE_FLAG(ONITEMINDENT
);
1632 TRANSLATE_FLAG(ONITEMLABEL
);
1633 TRANSLATE_FLAG(ONITEMRIGHT
);
1634 TRANSLATE_FLAG(ONITEMSTATEICON
);
1635 TRANSLATE_FLAG(TOLEFT
);
1636 TRANSLATE_FLAG(TORIGHT
);
1638 #undef TRANSLATE_FLAG
1640 return wxTreeItemId((WXHTREEITEM
) hitTestInfo
.hItem
);
1643 bool wxTreeCtrl::GetBoundingRect(const wxTreeItemId
& item
,
1645 bool textOnly
) const
1648 if ( TreeView_GetItemRect(GetHwnd(), HITEM(item
),
1651 rect
= wxRect(wxPoint(rc
.left
, rc
.top
), wxPoint(rc
.right
, rc
.bottom
));
1657 // couldn't retrieve rect: for example, item isn't visible
1662 // ----------------------------------------------------------------------------
1664 // ----------------------------------------------------------------------------
1666 static int CALLBACK
TreeView_CompareCallback(wxTreeItemData
*pItem1
,
1667 wxTreeItemData
*pItem2
,
1670 wxCHECK_MSG( pItem1
&& pItem2
, 0,
1671 wxT("sorting tree without data doesn't make sense") );
1673 return tree
->OnCompareItems(pItem1
->GetId(), pItem2
->GetId());
1676 int wxTreeCtrl::OnCompareItems(const wxTreeItemId
& item1
,
1677 const wxTreeItemId
& item2
)
1679 return wxStrcmp(GetItemText(item1
), GetItemText(item2
));
1682 void wxTreeCtrl::SortChildren(const wxTreeItemId
& item
)
1684 // rely on the fact that TreeView_SortChildren does the same thing as our
1685 // default behaviour, i.e. sorts items alphabetically and so call it
1686 // directly if we're not in derived class (much more efficient!)
1687 if ( GetClassInfo() == CLASSINFO(wxTreeCtrl
) )
1689 TreeView_SortChildren(GetHwnd(), HITEM(item
), 0);
1694 tvSort
.hParent
= HITEM(item
);
1695 tvSort
.lpfnCompare
= (PFNTVCOMPARE
)TreeView_CompareCallback
;
1696 tvSort
.lParam
= (LPARAM
)this;
1697 TreeView_SortChildrenCB(GetHwnd(), &tvSort
, 0 /* reserved */);
1701 // ----------------------------------------------------------------------------
1703 // ----------------------------------------------------------------------------
1705 bool wxTreeCtrl::MSWCommand(WXUINT cmd
, WXWORD id
)
1707 if ( cmd
== EN_UPDATE
)
1709 wxCommandEvent
event(wxEVT_COMMAND_TEXT_UPDATED
, id
);
1710 event
.SetEventObject( this );
1711 ProcessCommand(event
);
1713 else if ( cmd
== EN_KILLFOCUS
)
1715 wxCommandEvent
event(wxEVT_KILL_FOCUS
, id
);
1716 event
.SetEventObject( this );
1717 ProcessCommand(event
);
1725 // command processed
1729 // we hook into WndProc to process WM_MOUSEMOVE/WM_BUTTONUP messages - as we
1730 // only do it during dragging, minimize wxWin overhead (this is important for
1731 // WM_MOUSEMOVE as they're a lot of them) by catching Windows messages directly
1732 // instead of passing by wxWin events
1733 long wxTreeCtrl::MSWWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1735 bool processed
= FALSE
;
1738 bool isMultiple
= (GetWindowStyle() & wxTR_MULTIPLE
) != 0;
1740 if ( (nMsg
>= WM_MOUSEFIRST
) && (nMsg
<= WM_MOUSELAST
) )
1742 // we only process mouse messages here and these parameters have the same
1743 // meaning for all of them
1744 int x
= GET_X_LPARAM(lParam
),
1745 y
= GET_Y_LPARAM(lParam
);
1746 HTREEITEM htItem
= GetItemFromPoint(GetHwnd(), x
, y
);
1750 #if !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1751 case WM_LBUTTONDOWN
:
1752 if ( htItem
&& isMultiple
)
1754 if ( wParam
& MK_CONTROL
)
1758 // toggle selected state
1759 ToggleItemSelection(GetHwnd(), htItem
);
1761 ::SetFocus(GetHwnd(), htItem
);
1763 // reset on any click without Shift
1768 else if ( wParam
& MK_SHIFT
)
1770 // this selects all items between the starting one and
1773 if ( !m_htSelStart
)
1775 // take the focused item
1776 m_htSelStart
= (WXHTREEITEM
)
1777 TreeView_GetSelection(GetHwnd());
1780 SelectRange(GetHwnd(), HITEM(m_htSelStart
), htItem
,
1781 !(wParam
& MK_CONTROL
));
1783 ::SetFocus(GetHwnd(), htItem
);
1787 else // normal click
1789 // clear the selection and then let the default handler
1793 // prevent the click from starting in-place editing
1794 // when there was no selection in the control
1795 TreeView_SelectItem(GetHwnd(), 0);
1797 // reset on any click without Shift
1802 #endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1807 m_dragImage
->Move(wxPoint(x
, y
));
1810 // highlight the item as target (hiding drag image is
1811 // necessary - otherwise the display will be corrupted)
1812 m_dragImage
->Hide();
1813 TreeView_SelectDropTarget(GetHwnd(), htItem
);
1814 m_dragImage
->Show();
1823 m_dragImage
->EndDrag();
1827 // generate the drag end event
1828 wxTreeEvent
event(wxEVT_COMMAND_TREE_END_DRAG
, m_windowId
);
1830 event
.m_item
= (WXHTREEITEM
)htItem
;
1831 event
.m_pointDrag
= wxPoint(x
, y
);
1832 event
.SetEventObject(this);
1834 (void)GetEventHandler()->ProcessEvent(event
);
1836 // if we don't do it, the tree seems to think that 2 items
1837 // are selected simultaneously which is quite weird
1838 TreeView_SelectDropTarget(GetHwnd(), 0);
1843 #if !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1844 else if ( (nMsg
== WM_SETFOCUS
|| nMsg
== WM_KILLFOCUS
) && isMultiple
)
1846 // the tree control greys out the selected item when it loses focus and
1847 // paints it as selected again when it regains it, but it won't do it
1848 // for the other items itself - help it
1849 wxArrayTreeItemIds selections
;
1850 size_t count
= GetSelections(selections
);
1852 for ( size_t n
= 0; n
< count
; n
++ )
1854 // TreeView_GetItemRect() will return FALSE if item is not visible,
1855 // which may happen perfectly well
1856 if ( TreeView_GetItemRect(GetHwnd(), HITEM(selections
[n
]),
1859 ::InvalidateRect(GetHwnd(), &rect
, FALSE
);
1863 else if ( nMsg
== WM_KEYDOWN
&& isMultiple
)
1865 bool bCtrl
= wxIsCtrlDown(),
1866 bShift
= wxIsShiftDown();
1868 // we handle.arrows and space, but not page up/down and home/end: the
1869 // latter should be easy, but not the former
1871 HTREEITEM htSel
= (HTREEITEM
)TreeView_GetSelection(GetHwnd());
1872 if ( !m_htSelStart
)
1874 m_htSelStart
= (WXHTREEITEM
)htSel
;
1877 if ( wParam
== VK_SPACE
)
1881 ToggleItemSelection(GetHwnd(), htSel
);
1887 ::SelectItem(GetHwnd(), htSel
);
1892 else if ( wParam
== VK_UP
|| wParam
== VK_DOWN
)
1894 if ( !bCtrl
&& !bShift
)
1896 // no modifiers, just clear selection and then let the default
1897 // processing to take place
1902 (void)wxControl::MSWWindowProc(nMsg
, wParam
, lParam
);
1904 HTREEITEM htNext
= (HTREEITEM
)(wParam
== VK_UP
1905 ? TreeView_GetPrevVisible(GetHwnd(), htSel
)
1906 : TreeView_GetNextVisible(GetHwnd(), htSel
));
1910 // at the top/bottom
1916 SelectRange(GetHwnd(), HITEM(m_htSelStart
), htNext
);
1920 // without changing selection
1921 ::SetFocus(GetHwnd(), htNext
);
1928 #endif // !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1931 rc
= wxControl::MSWWindowProc(nMsg
, wParam
, lParam
);
1936 // process WM_NOTIFY Windows message
1937 bool wxTreeCtrl::MSWOnNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
1939 wxTreeEvent
event(wxEVT_NULL
, m_windowId
);
1940 wxEventType eventType
= wxEVT_NULL
;
1941 NMHDR
*hdr
= (NMHDR
*)lParam
;
1943 switch ( hdr
->code
)
1946 eventType
= wxEVT_COMMAND_TREE_BEGIN_DRAG
;
1949 case TVN_BEGINRDRAG
:
1951 if ( eventType
== wxEVT_NULL
)
1952 eventType
= wxEVT_COMMAND_TREE_BEGIN_RDRAG
;
1953 //else: left drag, already set above
1955 NM_TREEVIEW
*tv
= (NM_TREEVIEW
*)lParam
;
1957 event
.m_item
= (WXHTREEITEM
) tv
->itemNew
.hItem
;
1958 event
.m_pointDrag
= wxPoint(tv
->ptDrag
.x
, tv
->ptDrag
.y
);
1960 // don't allow dragging by default: the user code must
1961 // explicitly say that it wants to allow it to avoid breaking
1967 case TVN_BEGINLABELEDIT
:
1969 eventType
= wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT
;
1970 TV_DISPINFO
*info
= (TV_DISPINFO
*)lParam
;
1972 event
.m_item
= (WXHTREEITEM
) info
->item
.hItem
;
1973 event
.m_label
= info
->item
.pszText
;
1977 case TVN_DELETEITEM
:
1979 eventType
= wxEVT_COMMAND_TREE_DELETE_ITEM
;
1980 NM_TREEVIEW
*tv
= (NM_TREEVIEW
*)lParam
;
1982 event
.m_item
= (WXHTREEITEM
)tv
->itemOld
.hItem
;
1986 delete (wxTreeItemAttr
*)m_attrs
.
1987 Delete((long)tv
->itemOld
.hItem
);
1992 case TVN_ENDLABELEDIT
:
1994 eventType
= wxEVT_COMMAND_TREE_END_LABEL_EDIT
;
1995 TV_DISPINFO
*info
= (TV_DISPINFO
*)lParam
;
1997 event
.m_item
= (WXHTREEITEM
)info
->item
.hItem
;
1998 event
.m_label
= info
->item
.pszText
;
1999 if (info
->item
.pszText
== NULL
)
2004 case TVN_GETDISPINFO
:
2005 eventType
= wxEVT_COMMAND_TREE_GET_INFO
;
2008 case TVN_SETDISPINFO
:
2010 if ( eventType
== wxEVT_NULL
)
2011 eventType
= wxEVT_COMMAND_TREE_SET_INFO
;
2012 //else: get, already set above
2014 TV_DISPINFO
*info
= (TV_DISPINFO
*)lParam
;
2016 event
.m_item
= (WXHTREEITEM
) info
->item
.hItem
;
2020 case TVN_ITEMEXPANDING
:
2021 event
.m_code
= FALSE
;
2024 case TVN_ITEMEXPANDED
:
2026 NM_TREEVIEW
* tv
= (NM_TREEVIEW
*)lParam
;
2028 bool expand
= FALSE
;
2029 switch ( tv
->action
)
2040 wxLogDebug(wxT("unexpected code %d in TVN_ITEMEXPAND message"), tv
->action
);
2043 bool ing
= ((int)hdr
->code
== TVN_ITEMEXPANDING
);
2044 eventType
= g_events
[expand
][ing
];
2046 event
.m_item
= (WXHTREEITEM
) tv
->itemNew
.hItem
;
2052 eventType
= wxEVT_COMMAND_TREE_KEY_DOWN
;
2053 TV_KEYDOWN
*info
= (TV_KEYDOWN
*)lParam
;
2055 event
.m_code
= wxCharCodeMSWToWX(info
->wVKey
);
2057 // a separate event for Space/Return
2058 if ( !wxIsCtrlDown() && !wxIsShiftDown() &&
2059 ((info
->wVKey
== VK_SPACE
) || (info
->wVKey
== VK_RETURN
)) )
2061 wxTreeEvent
event2(wxEVT_COMMAND_TREE_ITEM_ACTIVATED
,
2063 event2
.SetEventObject(this);
2064 if ( !(GetWindowStyle() & wxTR_MULTIPLE
) )
2066 event2
.m_item
= GetSelection();
2068 //else: don't know how to get it
2070 (void)GetEventHandler()->ProcessEvent(event2
);
2075 case TVN_SELCHANGED
:
2076 eventType
= wxEVT_COMMAND_TREE_SEL_CHANGED
;
2079 case TVN_SELCHANGING
:
2081 if ( eventType
== wxEVT_NULL
)
2082 eventType
= wxEVT_COMMAND_TREE_SEL_CHANGING
;
2083 //else: already set above
2085 NM_TREEVIEW
* tv
= (NM_TREEVIEW
*)lParam
;
2087 event
.m_item
= (WXHTREEITEM
) tv
->itemNew
.hItem
;
2088 event
.m_itemOld
= (WXHTREEITEM
) tv
->itemOld
.hItem
;
2092 #if defined(_WIN32_IE) && _WIN32_IE >= 0x300 && !wxUSE_COMCTL32_SAFELY
2095 LPNMTVCUSTOMDRAW lptvcd
= (LPNMTVCUSTOMDRAW
)lParam
;
2096 NMCUSTOMDRAW
& nmcd
= lptvcd
->nmcd
;
2097 switch( nmcd
.dwDrawStage
)
2100 // if we've got any items with non standard attributes,
2101 // notify us before painting each item
2102 *result
= m_hasAnyAttr
? CDRF_NOTIFYITEMDRAW
2106 case CDDS_ITEMPREPAINT
:
2108 wxTreeItemAttr
*attr
=
2109 (wxTreeItemAttr
*)m_attrs
.Get(nmcd
.dwItemSpec
);
2113 // nothing to do for this item
2114 return CDRF_DODEFAULT
;
2118 wxColour colText
, colBack
;
2119 if ( attr
->HasFont() )
2121 wxFont font
= attr
->GetFont();
2122 hFont
= (HFONT
)font
.GetResourceHandle();
2129 if ( attr
->HasTextColour() )
2131 colText
= attr
->GetTextColour();
2135 colText
= GetForegroundColour();
2138 // selection colours should override ours
2139 if ( nmcd
.uItemState
& CDIS_SELECTED
)
2141 DWORD clrBk
= ::GetSysColor(COLOR_HIGHLIGHT
);
2142 lptvcd
->clrTextBk
= clrBk
;
2144 // try to make the text visible
2145 lptvcd
->clrText
= wxColourToRGB(colText
);
2146 lptvcd
->clrText
|= ~clrBk
;
2147 lptvcd
->clrText
&= 0x00ffffff;
2151 if ( attr
->HasBackgroundColour() )
2153 colBack
= attr
->GetBackgroundColour();
2157 colBack
= GetBackgroundColour();
2160 lptvcd
->clrText
= wxColourToRGB(colText
);
2161 lptvcd
->clrTextBk
= wxColourToRGB(colBack
);
2164 // note that if we wanted to set colours for
2165 // individual columns (subitems), we would have
2166 // returned CDRF_NOTIFYSUBITEMREDRAW from here
2169 ::SelectObject(nmcd
.hdc
, hFont
);
2171 *result
= CDRF_NEWFONT
;
2175 *result
= CDRF_DODEFAULT
;
2182 *result
= CDRF_DODEFAULT
;
2187 #endif // _WIN32_IE >= 0x300
2192 TV_HITTESTINFO tvhti
;
2193 ::GetCursorPos(&tvhti
.pt
);
2194 ::ScreenToClient(GetHwnd(), &tvhti
.pt
);
2195 if ( TreeView_HitTest(GetHwnd(), &tvhti
) )
2197 if ( tvhti
.flags
& TVHT_ONITEM
)
2199 event
.m_item
= (WXHTREEITEM
) tvhti
.hItem
;
2200 eventType
= (int)hdr
->code
== NM_DBLCLK
2201 ? wxEVT_COMMAND_TREE_ITEM_ACTIVATED
2202 : wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK
;
2211 return wxControl::MSWOnNotify(idCtrl
, lParam
, result
);
2214 event
.SetEventObject(this);
2215 event
.SetEventType(eventType
);
2217 bool processed
= GetEventHandler()->ProcessEvent(event
);
2220 switch ( hdr
->code
)
2223 // we translate NM_DBLCLK into ACTIVATED event, so don't interpret
2224 // the return code of this event handler as the return value for
2225 // NM_DBLCLK - otherwise, double clicking the item to toggle its
2226 // expanded status would never work
2231 case TVN_BEGINRDRAG
:
2232 if ( event
.IsAllowed() )
2234 // normally this is impossible because the m_dragImage is
2235 // deleted once the drag operation is over
2236 wxASSERT_MSG( !m_dragImage
, _T("starting to drag once again?") );
2238 m_dragImage
= new wxDragImage(*this, event
.m_item
);
2239 m_dragImage
->BeginDrag(wxPoint(0, 0), this);
2240 m_dragImage
->Show();
2244 case TVN_DELETEITEM
:
2246 // NB: we might process this message using wxWindows event
2247 // tables, but due to overhead of wxWin event system we
2248 // prefer to do it here ourself (otherwise deleting a tree
2249 // with many items is just too slow)
2250 NM_TREEVIEW
* tv
= (NM_TREEVIEW
*)lParam
;
2252 wxTreeItemId item
= event
.m_item
;
2253 if ( HasIndirectData(item
) )
2255 wxTreeItemIndirectData
*data
= (wxTreeItemIndirectData
*)
2257 delete data
; // can't be NULL here
2259 m_itemsWithIndirectData
.Remove(item
);
2263 wxTreeItemData
*data
= (wxTreeItemData
*)tv
->itemOld
.lParam
;
2264 delete data
; // may be NULL, ok
2267 processed
= TRUE
; // Make sure we don't get called twice
2271 case TVN_BEGINLABELEDIT
:
2272 // return TRUE to cancel label editing
2273 *result
= !event
.IsAllowed();
2276 case TVN_ENDLABELEDIT
:
2277 // return TRUE to set the label to the new string
2278 *result
= event
.IsAllowed();
2280 // ensure that we don't have the text ctrl which is going to be
2285 case TVN_SELCHANGING
:
2286 case TVN_ITEMEXPANDING
:
2287 // return TRUE to prevent the action from happening
2288 *result
= !event
.IsAllowed();
2291 case TVN_GETDISPINFO
:
2292 // NB: so far the user can't set the image himself anyhow, so do it
2293 // anyway - but this may change later
2294 if ( /* !processed && */ 1 )
2296 wxTreeItemId item
= event
.m_item
;
2297 TV_DISPINFO
*info
= (TV_DISPINFO
*)lParam
;
2298 if ( info
->item
.mask
& TVIF_IMAGE
)
2301 DoGetItemImageFromData
2304 IsExpanded(item
) ? wxTreeItemIcon_Expanded
2305 : wxTreeItemIcon_Normal
2308 if ( info
->item
.mask
& TVIF_SELECTEDIMAGE
)
2310 info
->item
.iSelectedImage
=
2311 DoGetItemImageFromData
2314 IsExpanded(item
) ? wxTreeItemIcon_SelectedExpanded
2315 : wxTreeItemIcon_Selected
2322 // for the other messages the return value is ignored and there is
2323 // nothing special to do
2329 // ----------------------------------------------------------------------------
2331 // ----------------------------------------------------------------------------
2333 IMPLEMENT_DYNAMIC_CLASS(wxTreeEvent
, wxNotifyEvent
)
2335 wxTreeEvent::wxTreeEvent(wxEventType commandType
, int id
)
2336 : wxNotifyEvent(commandType
, id
)