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
7
// RCS-ID: $Id: treectrl.cpp,v 1.208.2.1 2005/12/01 11:05:31 ABX Exp $
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
// include <commctrl.h> "properly"
36
#include "wx/msw/wrapcctl.h"
38
#include "wx/msw/missing.h"
40
// Set this to 1 to be _absolutely_ sure that repainting will work for all
41
// comctl32.dll versions
42
#define wxUSE_COMCTL32_SAFELY 0
46
#include "wx/dynarray.h"
47
#include "wx/imaglist.h"
48
#include "wx/settings.h"
49
#include "wx/msw/treectrl.h"
50
#include "wx/msw/dragimag.h"
52
// macros to hide the cast ugliness
53
// --------------------------------
55
// ptr is the real item id, i.e. wxTreeItemId::m_pItem
56
#define HITEM_PTR(ptr) (HTREEITEM)(ptr)
58
// item here is a wxTreeItemId
59
#define HITEM(item) HITEM_PTR((item).m_pItem)
61
// the native control doesn't support multiple selections under MSW and we
62
// have 2 ways to emulate them: either using TVS_CHECKBOXES style and let
63
// checkboxes be the selection status (checked == selected) or by really
64
// emulating everything, i.e. intercepting mouse and key events &c. The first
65
// approach is much easier but doesn't work with comctl32.dll < 4.71 and also
67
#define wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE 0
69
// ----------------------------------------------------------------------------
71
// ----------------------------------------------------------------------------
73
// wrapper for TreeView_HitTest
74
static HTREEITEM GetItemFromPoint(HWND hwndTV, int x, int y)
80
return (HTREEITEM)TreeView_HitTest(hwndTV, &tvht);
83
#if !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
85
// wrappers for TreeView_GetItem/TreeView_SetItem
86
static bool IsItemSelected(HWND hwndTV, HTREEITEM hItem)
90
tvi.mask = TVIF_STATE | TVIF_HANDLE;
91
tvi.stateMask = TVIS_SELECTED;
94
if ( !TreeView_GetItem(hwndTV, &tvi) )
96
wxLogLastError(wxT("TreeView_GetItem"));
99
return (tvi.state & TVIS_SELECTED) != 0;
102
static bool SelectItem(HWND hwndTV, HTREEITEM hItem, bool select = true)
105
tvi.mask = TVIF_STATE | TVIF_HANDLE;
106
tvi.stateMask = TVIS_SELECTED;
107
tvi.state = select ? TVIS_SELECTED : 0;
110
if ( TreeView_SetItem(hwndTV, &tvi) == -1 )
112
wxLogLastError(wxT("TreeView_SetItem"));
119
static inline void UnselectItem(HWND hwndTV, HTREEITEM htItem)
121
SelectItem(hwndTV, htItem, false);
124
static inline void ToggleItemSelection(HWND hwndTV, HTREEITEM htItem)
126
SelectItem(hwndTV, htItem, !IsItemSelected(hwndTV, htItem));
129
// helper function which selects all items in a range and, optionally,
130
// unselects all others
131
static void SelectRange(HWND hwndTV,
134
bool unselectOthers = true)
136
// find the first (or last) item and select it
138
HTREEITEM htItem = (HTREEITEM)TreeView_GetRoot(hwndTV);
139
while ( htItem && cont )
141
if ( (htItem == htFirst) || (htItem == htLast) )
143
if ( !IsItemSelected(hwndTV, htItem) )
145
SelectItem(hwndTV, htItem);
152
if ( unselectOthers && IsItemSelected(hwndTV, htItem) )
154
UnselectItem(hwndTV, htItem);
158
htItem = (HTREEITEM)TreeView_GetNextVisible(hwndTV, htItem);
161
// select the items in range
162
cont = htFirst != htLast;
163
while ( htItem && cont )
165
if ( !IsItemSelected(hwndTV, htItem) )
167
SelectItem(hwndTV, htItem);
170
cont = (htItem != htFirst) && (htItem != htLast);
172
htItem = (HTREEITEM)TreeView_GetNextVisible(hwndTV, htItem);
176
if ( unselectOthers )
180
if ( IsItemSelected(hwndTV, htItem) )
182
UnselectItem(hwndTV, htItem);
185
htItem = (HTREEITEM)TreeView_GetNextVisible(hwndTV, htItem);
189
// seems to be necessary - otherwise the just selected items don't always
190
// appear as selected
191
UpdateWindow(hwndTV);
194
// helper function which tricks the standard control into changing the focused
195
// item without changing anything else (if someone knows why Microsoft doesn't
196
// allow to do it by just setting TVIS_FOCUSED flag, please tell me!)
197
static void SetFocus(HWND hwndTV, HTREEITEM htItem)
200
HTREEITEM htFocus = (HTREEITEM)TreeView_GetSelection(hwndTV);
205
if ( htItem != htFocus )
207
// remember the selection state of the item
208
bool wasSelected = IsItemSelected(hwndTV, htItem);
210
if ( htFocus && IsItemSelected(hwndTV, htFocus) )
212
// prevent the tree from unselecting the old focus which it
213
// would do by default (TreeView_SelectItem unselects the
215
TreeView_SelectItem(hwndTV, 0);
216
SelectItem(hwndTV, htFocus);
219
TreeView_SelectItem(hwndTV, htItem);
223
// need to clear the selection which TreeView_SelectItem() gave
225
UnselectItem(hwndTV, htItem);
227
//else: was selected, still selected - ok
229
//else: nothing to do, focus already there
235
bool wasFocusSelected = IsItemSelected(hwndTV, htFocus);
237
// just clear the focus
238
TreeView_SelectItem(hwndTV, 0);
240
if ( wasFocusSelected )
242
// restore the selection state
243
SelectItem(hwndTV, htFocus);
246
//else: nothing to do, no focus already
250
#endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
252
// ----------------------------------------------------------------------------
254
// ----------------------------------------------------------------------------
256
// a convenient wrapper around TV_ITEM struct which adds a ctor
258
#pragma warning( disable : 4097 ) // inheriting from typedef
261
struct wxTreeViewItem : public TV_ITEM
263
wxTreeViewItem(const wxTreeItemId& item, // the item handle
264
UINT mask_, // fields which are valid
265
UINT stateMask_ = 0) // for TVIF_STATE only
269
// hItem member is always valid
270
mask = mask_ | TVIF_HANDLE;
271
stateMask = stateMask_;
276
// wxVirutalNode is used in place of a single root when 'hidden' root is
278
class wxVirtualNode : public wxTreeViewItem
281
wxVirtualNode(wxTreeItemData *data)
282
: wxTreeViewItem(TVI_ROOT, 0)
292
wxTreeItemData *GetData() const { return m_data; }
293
void SetData(wxTreeItemData *data) { delete m_data; m_data = data; }
296
wxTreeItemData *m_data;
298
DECLARE_NO_COPY_CLASS(wxVirtualNode)
302
#pragma warning( default : 4097 )
305
// a macro to get the virtual root, returns NULL if none
306
#define GET_VIRTUAL_ROOT() ((wxVirtualNode *)m_pVirtualRoot)
308
// returns true if the item is the virtual root
309
#define IS_VIRTUAL_ROOT(item) (HITEM(item) == TVI_ROOT)
311
// a class which encapsulates the tree traversal logic: it vists all (unless
312
// OnVisit() returns false) items under the given one
313
class wxTreeTraversal
316
wxTreeTraversal(const wxTreeCtrl *tree)
321
// do traverse the tree: visit all items (recursively by default) under the
322
// given one; return true if all items were traversed or false if the
323
// traversal was aborted because OnVisit returned false
324
bool DoTraverse(const wxTreeItemId& root, bool recursively = true);
326
// override this function to do whatever is needed for each item, return
327
// false to stop traversing
328
virtual bool OnVisit(const wxTreeItemId& item) = 0;
331
const wxTreeCtrl *GetTree() const { return m_tree; }
334
bool Traverse(const wxTreeItemId& root, bool recursively);
336
const wxTreeCtrl *m_tree;
338
DECLARE_NO_COPY_CLASS(wxTreeTraversal)
341
// internal class for getting the selected items
342
class TraverseSelections : public wxTreeTraversal
345
TraverseSelections(const wxTreeCtrl *tree,
346
wxArrayTreeItemIds& selections)
347
: wxTreeTraversal(tree), m_selections(selections)
349
m_selections.Empty();
351
if (tree->GetCount() > 0)
352
DoTraverse(tree->GetRootItem());
355
virtual bool OnVisit(const wxTreeItemId& item)
357
// can't visit a virtual node.
358
if ( (GetTree()->GetRootItem() == item) && (GetTree()->GetWindowStyle() & wxTR_HIDE_ROOT))
363
#if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
364
if ( GetTree()->IsItemChecked(item) )
366
if ( ::IsItemSelected(GetHwndOf(GetTree()), HITEM(item)) )
369
m_selections.Add(item);
375
size_t GetCount() const { return m_selections.GetCount(); }
378
wxArrayTreeItemIds& m_selections;
380
DECLARE_NO_COPY_CLASS(TraverseSelections)
383
// internal class for counting tree items
384
class TraverseCounter : public wxTreeTraversal
387
TraverseCounter(const wxTreeCtrl *tree,
388
const wxTreeItemId& root,
390
: wxTreeTraversal(tree)
394
DoTraverse(root, recursively);
397
virtual bool OnVisit(const wxTreeItemId& WXUNUSED(item))
404
size_t GetCount() const { return m_count; }
409
DECLARE_NO_COPY_CLASS(TraverseCounter)
412
// ----------------------------------------------------------------------------
413
// This class is needed for support of different images: the Win32 common
414
// control natively supports only 2 images (the normal one and another for the
415
// selected state). We wish to provide support for 2 more of them for folder
416
// items (i.e. those which have children): for expanded state and for expanded
417
// selected state. For this we use this structure to store the additional items
420
// There is only one problem with this: when we retrieve the item's data, we
421
// don't know whether we get a pointer to wxTreeItemData or
422
// wxTreeItemIndirectData. So we always set the item id to an invalid value
423
// in this class and the code using the client data checks for it and retrieves
424
// the real client data in this case.
425
// ----------------------------------------------------------------------------
427
class wxTreeItemIndirectData : public wxTreeItemData
430
// ctor associates this data with the item and the real item data becomes
431
// available through our GetData() method
432
wxTreeItemIndirectData(wxTreeCtrl *tree, const wxTreeItemId& item)
434
for ( size_t n = 0; n < WXSIZEOF(m_images); n++ )
440
m_data = tree->GetItemData(item);
442
// and set ourselves as the new one
443
tree->SetIndirectItemData(item, this);
445
// we must have the invalid value for the item
449
// dtor deletes the associated data as well
450
virtual ~wxTreeItemIndirectData() { delete m_data; }
453
// get the real data associated with the item
454
wxTreeItemData *GetData() const { return m_data; }
456
void SetData(wxTreeItemData *data) { m_data = data; }
458
// do we have such image?
459
bool HasImage(wxTreeItemIcon which) const { return m_images[which] != -1; }
461
int GetImage(wxTreeItemIcon which) const { return m_images[which]; }
463
void SetImage(int image, wxTreeItemIcon which) { m_images[which] = image; }
466
// all the images associated with the item
467
int m_images[wxTreeItemIcon_Max];
469
// the real client data
470
wxTreeItemData *m_data;
472
DECLARE_NO_COPY_CLASS(wxTreeItemIndirectData)
475
// ----------------------------------------------------------------------------
477
// ----------------------------------------------------------------------------
479
#if wxUSE_EXTENDED_RTTI
480
WX_DEFINE_FLAGS( wxTreeCtrlStyle )
482
wxBEGIN_FLAGS( wxTreeCtrlStyle )
483
// new style border flags, we put them first to
484
// use them for streaming out
485
wxFLAGS_MEMBER(wxBORDER_SIMPLE)
486
wxFLAGS_MEMBER(wxBORDER_SUNKEN)
487
wxFLAGS_MEMBER(wxBORDER_DOUBLE)
488
wxFLAGS_MEMBER(wxBORDER_RAISED)
489
wxFLAGS_MEMBER(wxBORDER_STATIC)
490
wxFLAGS_MEMBER(wxBORDER_NONE)
492
// old style border flags
493
wxFLAGS_MEMBER(wxSIMPLE_BORDER)
494
wxFLAGS_MEMBER(wxSUNKEN_BORDER)
495
wxFLAGS_MEMBER(wxDOUBLE_BORDER)
496
wxFLAGS_MEMBER(wxRAISED_BORDER)
497
wxFLAGS_MEMBER(wxSTATIC_BORDER)
498
wxFLAGS_MEMBER(wxBORDER)
500
// standard window styles
501
wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
502
wxFLAGS_MEMBER(wxCLIP_CHILDREN)
503
wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
504
wxFLAGS_MEMBER(wxWANTS_CHARS)
505
wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
506
wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
507
wxFLAGS_MEMBER(wxVSCROLL)
508
wxFLAGS_MEMBER(wxHSCROLL)
510
wxFLAGS_MEMBER(wxTR_EDIT_LABELS)
511
wxFLAGS_MEMBER(wxTR_NO_BUTTONS)
512
wxFLAGS_MEMBER(wxTR_HAS_BUTTONS)
513
wxFLAGS_MEMBER(wxTR_TWIST_BUTTONS)
514
wxFLAGS_MEMBER(wxTR_NO_LINES)
515
wxFLAGS_MEMBER(wxTR_FULL_ROW_HIGHLIGHT)
516
wxFLAGS_MEMBER(wxTR_LINES_AT_ROOT)
517
wxFLAGS_MEMBER(wxTR_HIDE_ROOT)
518
wxFLAGS_MEMBER(wxTR_ROW_LINES)
519
wxFLAGS_MEMBER(wxTR_HAS_VARIABLE_ROW_HEIGHT)
520
wxFLAGS_MEMBER(wxTR_SINGLE)
521
wxFLAGS_MEMBER(wxTR_MULTIPLE)
522
wxFLAGS_MEMBER(wxTR_EXTENDED)
523
wxFLAGS_MEMBER(wxTR_DEFAULT_STYLE)
525
wxEND_FLAGS( wxTreeCtrlStyle )
527
IMPLEMENT_DYNAMIC_CLASS_XTI(wxTreeCtrl, wxControl,"wx/treectrl.h")
529
wxBEGIN_PROPERTIES_TABLE(wxTreeCtrl)
530
wxEVENT_PROPERTY( TextUpdated , wxEVT_COMMAND_TEXT_UPDATED , wxCommandEvent )
531
wxEVENT_RANGE_PROPERTY( TreeEvent , wxEVT_COMMAND_TREE_BEGIN_DRAG , wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK , wxTreeEvent )
532
wxPROPERTY_FLAGS( WindowStyle , wxTreeCtrlStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
533
wxEND_PROPERTIES_TABLE()
535
wxBEGIN_HANDLERS_TABLE(wxTreeCtrl)
536
wxEND_HANDLERS_TABLE()
538
wxCONSTRUCTOR_5( wxTreeCtrl , wxWindow* , Parent , wxWindowID , Id , wxPoint , Position , wxSize , Size , long , WindowStyle )
540
IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxControl)
543
// ----------------------------------------------------------------------------
545
// ----------------------------------------------------------------------------
547
// indices in gs_expandEvents table below
562
// handy table for sending events - it has to be initialized during run-time
563
// now so can't be const any more
564
static /* const */ wxEventType gs_expandEvents[IDX_WHAT_MAX][IDX_HOW_MAX];
567
but logically it's a const table with the following entries:
570
{ wxEVT_COMMAND_TREE_ITEM_COLLAPSED, wxEVT_COMMAND_TREE_ITEM_COLLAPSING },
571
{ wxEVT_COMMAND_TREE_ITEM_EXPANDED, wxEVT_COMMAND_TREE_ITEM_EXPANDING }
575
// ============================================================================
577
// ============================================================================
579
// ----------------------------------------------------------------------------
581
// ----------------------------------------------------------------------------
583
bool wxTreeTraversal::DoTraverse(const wxTreeItemId& root, bool recursively)
585
if ( !OnVisit(root) )
588
return Traverse(root, recursively);
591
bool wxTreeTraversal::Traverse(const wxTreeItemId& root, bool recursively)
593
wxTreeItemIdValue cookie;
594
wxTreeItemId child = m_tree->GetFirstChild(root, cookie);
595
while ( child.IsOk() )
597
// depth first traversal
598
if ( recursively && !Traverse(child, true) )
601
if ( !OnVisit(child) )
604
child = m_tree->GetNextChild(root, cookie);
610
// ----------------------------------------------------------------------------
611
// construction and destruction
612
// ----------------------------------------------------------------------------
614
void wxTreeCtrl::Init()
616
m_imageListNormal = NULL;
617
m_imageListState = NULL;
618
m_ownsImageListNormal = m_ownsImageListState = false;
620
m_hasAnyAttr = false;
622
m_pVirtualRoot = NULL;
624
// initialize the global array of events now as it can't be done statically
625
// with the wxEVT_XXX values being allocated during run-time only
626
gs_expandEvents[IDX_COLLAPSE][IDX_DONE] = wxEVT_COMMAND_TREE_ITEM_COLLAPSED;
627
gs_expandEvents[IDX_COLLAPSE][IDX_DOING] = wxEVT_COMMAND_TREE_ITEM_COLLAPSING;
628
gs_expandEvents[IDX_EXPAND][IDX_DONE] = wxEVT_COMMAND_TREE_ITEM_EXPANDED;
629
gs_expandEvents[IDX_EXPAND][IDX_DOING] = wxEVT_COMMAND_TREE_ITEM_EXPANDING;
632
bool wxTreeCtrl::Create(wxWindow *parent,
637
const wxValidator& validator,
638
const wxString& name)
642
if ( (style & wxBORDER_MASK) == wxBORDER_DEFAULT )
643
style |= wxBORDER_SUNKEN;
645
if ( !CreateControl(parent, id, pos, size, style, validator, name) )
649
DWORD wstyle = MSWGetStyle(m_windowStyle, & exStyle);
650
wstyle |= WS_TABSTOP | TVS_SHOWSELALWAYS;
652
if ((m_windowStyle & wxTR_NO_LINES) == 0)
653
wstyle |= TVS_HASLINES;
654
if ( m_windowStyle & wxTR_HAS_BUTTONS )
655
wstyle |= TVS_HASBUTTONS;
657
if ( m_windowStyle & wxTR_EDIT_LABELS )
658
wstyle |= TVS_EDITLABELS;
660
if ( m_windowStyle & wxTR_LINES_AT_ROOT )
661
wstyle |= TVS_LINESATROOT;
663
if ( m_windowStyle & wxTR_FULL_ROW_HIGHLIGHT )
665
if ( wxApp::GetComCtl32Version() >= 471 )
666
wstyle |= TVS_FULLROWSELECT;
669
// using TVS_CHECKBOXES for emulation of a multiselection tree control
670
// doesn't work without the new enough headers
671
#if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE && \
672
!defined( __GNUWIN32_OLD__ ) && \
673
!defined( __BORLANDC__ ) && \
674
!defined( __WATCOMC__ ) && \
675
(!defined(__VISUALC__) || (__VISUALC__ > 1010))
677
// we emulate the multiple selection tree controls by using checkboxes: set
678
// up the image list we need for this if we do have multiple selections
679
if ( m_windowStyle & wxTR_MULTIPLE )
680
wstyle |= TVS_CHECKBOXES;
681
#endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
683
#if !defined(__WXWINCE__) && defined(TVS_INFOTIP)
684
// Need so that TVN_GETINFOTIP messages will be sent
685
wstyle |= TVS_INFOTIP;
688
// Create the tree control.
689
if ( !MSWCreateControl(WC_TREEVIEW, wstyle, pos, size) )
692
#if wxUSE_COMCTL32_SAFELY
693
wxWindow::SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
694
wxWindow::SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
696
SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
697
SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
699
// This works around a bug in the Windows tree control whereby for some versions
700
// of comctrl32, setting any colour actually draws the background in black.
701
// This will initialise the background to the system colour.
702
// THIS FIX NOW REVERTED since it caused problems on _other_ systems.
703
// Assume the user has an updated comctl32.dll.
704
::SendMessage(GetHwnd(), TVM_SETBKCOLOR, 0,-1);
705
wxWindow::SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
706
SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
710
// VZ: this is some experimental code which may be used to get the
711
// TVS_CHECKBOXES style functionality for comctl32.dll < 4.71.
712
// AFAIK, the standard DLL does about the same thing anyhow.
714
if ( m_windowStyle & wxTR_MULTIPLE )
718
// create the DC compatible with the current screen
719
HDC hdcMem = CreateCompatibleDC(NULL);
721
// create a mono bitmap of the standard size
722
int x = ::GetSystemMetrics(SM_CXMENUCHECK);
723
int y = ::GetSystemMetrics(SM_CYMENUCHECK);
724
wxImageList imagelistCheckboxes(x, y, false, 2);
725
HBITMAP hbmpCheck = CreateBitmap(x, y, // bitmap size
726
1, // # of color planes
727
1, // # bits needed for one pixel
728
0); // array containing colour data
729
SelectObject(hdcMem, hbmpCheck);
731
// then draw a check mark into it
732
RECT rect = { 0, 0, x, y };
733
if ( !::DrawFrameControl(hdcMem, &rect,
735
DFCS_BUTTONCHECK | DFCS_CHECKED) )
737
wxLogLastError(wxT("DrawFrameControl(check)"));
740
bmp.SetHBITMAP((WXHBITMAP)hbmpCheck);
741
imagelistCheckboxes.Add(bmp);
743
if ( !::DrawFrameControl(hdcMem, &rect,
747
wxLogLastError(wxT("DrawFrameControl(uncheck)"));
750
bmp.SetHBITMAP((WXHBITMAP)hbmpCheck);
751
imagelistCheckboxes.Add(bmp);
757
SetStateImageList(&imagelistCheckboxes);
761
wxSetCCUnicodeFormat(GetHwnd());
766
wxTreeCtrl::~wxTreeCtrl()
768
// delete any attributes
771
WX_CLEAR_HASH_MAP(wxMapTreeAttr, m_attrs);
773
// prevent TVN_DELETEITEM handler from deleting the attributes again!
774
m_hasAnyAttr = false;
779
// delete user data to prevent memory leaks
780
// also deletes hidden root node storage.
783
if (m_ownsImageListNormal) delete m_imageListNormal;
784
if (m_ownsImageListState) delete m_imageListState;
787
// ----------------------------------------------------------------------------
789
// ----------------------------------------------------------------------------
791
/* static */ wxVisualAttributes
792
wxTreeCtrl::GetClassDefaultAttributes(wxWindowVariant variant)
794
wxVisualAttributes attrs = GetCompositeControlsDefaultAttributes(variant);
796
// common controls have their own default font
797
attrs.font = wxGetCCDefaultFont();
803
// simple wrappers which add error checking in debug mode
805
bool wxTreeCtrl::DoGetItem(wxTreeViewItem* tvItem) const
807
wxCHECK_MSG( tvItem->hItem != TVI_ROOT, false,
808
_T("can't retrieve virtual root item") );
810
if ( !TreeView_GetItem(GetHwnd(), tvItem) )
812
wxLogLastError(wxT("TreeView_GetItem"));
820
void wxTreeCtrl::DoSetItem(wxTreeViewItem* tvItem)
822
if ( TreeView_SetItem(GetHwnd(), tvItem) == -1 )
824
wxLogLastError(wxT("TreeView_SetItem"));
828
size_t wxTreeCtrl::GetCount() const
830
return (size_t)TreeView_GetCount(GetHwnd());
833
unsigned int wxTreeCtrl::GetIndent() const
835
return TreeView_GetIndent(GetHwnd());
838
void wxTreeCtrl::SetIndent(unsigned int indent)
840
TreeView_SetIndent(GetHwnd(), indent);
843
wxImageList *wxTreeCtrl::GetImageList() const
845
return m_imageListNormal;
848
wxImageList *wxTreeCtrl::GetStateImageList() const
850
return m_imageListState;
853
void wxTreeCtrl::SetAnyImageList(wxImageList *imageList, int which)
856
(void) TreeView_SetImageList(GetHwnd(),
857
imageList ? imageList->GetHIMAGELIST() : 0,
861
void wxTreeCtrl::SetImageList(wxImageList *imageList)
863
if (m_ownsImageListNormal)
864
delete m_imageListNormal;
866
SetAnyImageList(m_imageListNormal = imageList, TVSIL_NORMAL);
867
m_ownsImageListNormal = false;
870
void wxTreeCtrl::SetStateImageList(wxImageList *imageList)
872
if (m_ownsImageListState) delete m_imageListState;
873
SetAnyImageList(m_imageListState = imageList, TVSIL_STATE);
874
m_ownsImageListState = false;
877
void wxTreeCtrl::AssignImageList(wxImageList *imageList)
879
SetImageList(imageList);
880
m_ownsImageListNormal = true;
883
void wxTreeCtrl::AssignStateImageList(wxImageList *imageList)
885
SetStateImageList(imageList);
886
m_ownsImageListState = true;
889
size_t wxTreeCtrl::GetChildrenCount(const wxTreeItemId& item,
890
bool recursively) const
892
wxCHECK_MSG( item.IsOk(), 0u, wxT("invalid tree item") );
894
TraverseCounter counter(this, item, recursively);
895
return counter.GetCount() - 1;
898
// ----------------------------------------------------------------------------
900
// ----------------------------------------------------------------------------
902
bool wxTreeCtrl::SetBackgroundColour(const wxColour &colour)
904
#if !wxUSE_COMCTL32_SAFELY
905
if ( !wxWindowBase::SetBackgroundColour(colour) )
908
::SendMessage(GetHwnd(), TVM_SETBKCOLOR, 0, colour.GetPixel());
914
bool wxTreeCtrl::SetForegroundColour(const wxColour &colour)
916
#if !wxUSE_COMCTL32_SAFELY
917
if ( !wxWindowBase::SetForegroundColour(colour) )
920
::SendMessage(GetHwnd(), TVM_SETTEXTCOLOR, 0, colour.GetPixel());
926
// ----------------------------------------------------------------------------
928
// ----------------------------------------------------------------------------
930
wxString wxTreeCtrl::GetItemText(const wxTreeItemId& item) const
932
wxCHECK_MSG( item.IsOk(), wxEmptyString, wxT("invalid tree item") );
934
wxChar buf[512]; // the size is arbitrary...
936
wxTreeViewItem tvItem(item, TVIF_TEXT);
937
tvItem.pszText = buf;
938
tvItem.cchTextMax = WXSIZEOF(buf);
939
if ( !DoGetItem(&tvItem) )
941
// don't return some garbage which was on stack, but an empty string
945
return wxString(buf);
948
void wxTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text)
950
wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
952
if ( IS_VIRTUAL_ROOT(item) )
955
wxTreeViewItem tvItem(item, TVIF_TEXT);
956
tvItem.pszText = (wxChar *)text.c_str(); // conversion is ok
959
// when setting the text of the item being edited, the text control should
960
// be updated to reflect the new text as well, otherwise calling
961
// SetItemText() in the OnBeginLabelEdit() handler doesn't have any effect
963
// don't use GetEditControl() here because m_textCtrl is not set yet
964
HWND hwndEdit = TreeView_GetEditControl(GetHwnd());
967
if ( item == m_idEdited )
969
::SetWindowText(hwndEdit, text);
974
int wxTreeCtrl::DoGetItemImageFromData(const wxTreeItemId& item,
975
wxTreeItemIcon which) const
977
wxTreeViewItem tvItem(item, TVIF_PARAM);
978
if ( !DoGetItem(&tvItem) )
983
return ((wxTreeItemIndirectData *)tvItem.lParam)->GetImage(which);
986
void wxTreeCtrl::DoSetItemImageFromData(const wxTreeItemId& item,
988
wxTreeItemIcon which) const
990
wxTreeViewItem tvItem(item, TVIF_PARAM);
991
if ( !DoGetItem(&tvItem) )
996
wxTreeItemIndirectData *data = ((wxTreeItemIndirectData *)tvItem.lParam);
998
data->SetImage(image, which);
1000
// make sure that we have selected images as well
1001
if ( which == wxTreeItemIcon_Normal &&
1002
!data->HasImage(wxTreeItemIcon_Selected) )
1004
data->SetImage(image, wxTreeItemIcon_Selected);
1007
if ( which == wxTreeItemIcon_Expanded &&
1008
!data->HasImage(wxTreeItemIcon_SelectedExpanded) )
1010
data->SetImage(image, wxTreeItemIcon_SelectedExpanded);
1014
void wxTreeCtrl::DoSetItemImages(const wxTreeItemId& item,
1018
wxTreeViewItem tvItem(item, TVIF_IMAGE | TVIF_SELECTEDIMAGE);
1019
tvItem.iSelectedImage = imageSel;
1020
tvItem.iImage = image;
1024
int wxTreeCtrl::GetItemImage(const wxTreeItemId& item,
1025
wxTreeItemIcon which) const
1027
wxCHECK_MSG( item.IsOk(), -1, wxT("invalid tree item") );
1029
if ( (HITEM(item) == TVI_ROOT) && (m_windowStyle & wxTR_HIDE_ROOT) )
1031
// TODO: Maybe a hidden root can still provide images?
1035
if ( HasIndirectData(item) )
1037
return DoGetItemImageFromData(item, which);
1044
wxFAIL_MSG( wxT("unknown tree item image type") );
1046
case wxTreeItemIcon_Normal:
1050
case wxTreeItemIcon_Selected:
1051
mask = TVIF_SELECTEDIMAGE;
1054
case wxTreeItemIcon_Expanded:
1055
case wxTreeItemIcon_SelectedExpanded:
1059
wxTreeViewItem tvItem(item, mask);
1062
return mask == TVIF_IMAGE ? tvItem.iImage : tvItem.iSelectedImage;
1065
void wxTreeCtrl::SetItemImage(const wxTreeItemId& item, int image,
1066
wxTreeItemIcon which)
1068
wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1070
if ( IS_VIRTUAL_ROOT(item) )
1072
// TODO: Maybe a hidden root can still store images?
1082
wxFAIL_MSG( wxT("unknown tree item image type") );
1085
case wxTreeItemIcon_Normal:
1087
const int imageNormalOld = GetItemImage(item);
1088
const int imageSelOld =
1089
GetItemImage(item, wxTreeItemIcon_Selected);
1091
// always set the normal image
1092
imageNormal = image;
1094
// if the selected and normal images were the same, they should
1095
// be the same after the update, otherwise leave the selected
1097
imageSel = imageNormalOld == imageSelOld ? image : imageSelOld;
1101
case wxTreeItemIcon_Selected:
1102
imageNormal = GetItemImage(item);
1106
case wxTreeItemIcon_Expanded:
1107
case wxTreeItemIcon_SelectedExpanded:
1108
if ( !HasIndirectData(item) )
1110
// we need to get the old images first, because after we create
1111
// the wxTreeItemIndirectData GetItemXXXImage() will use it to
1113
imageNormal = GetItemImage(item);
1114
imageSel = GetItemImage(item, wxTreeItemIcon_Selected);
1116
// if it doesn't have it yet, add it
1117
wxTreeItemIndirectData *data = new
1118
wxTreeItemIndirectData(this, item);
1120
// copy the data to the new location
1121
data->SetImage(imageNormal, wxTreeItemIcon_Normal);
1122
data->SetImage(imageSel, wxTreeItemIcon_Selected);
1125
DoSetItemImageFromData(item, image, which);
1127
// reset the normal/selected images because we won't use them any
1128
// more - now they're stored inside the indirect data
1130
imageSel = I_IMAGECALLBACK;
1134
// NB: at least in version 5.00.0518.9 of comctl32.dll we need to always
1135
// change both normal and selected image - otherwise the change simply
1136
// doesn't take place!
1137
DoSetItemImages(item, imageNormal, imageSel);
1140
wxTreeItemData *wxTreeCtrl::GetItemData(const wxTreeItemId& item) const
1142
wxCHECK_MSG( item.IsOk(), NULL, wxT("invalid tree item") );
1144
wxTreeViewItem tvItem(item, TVIF_PARAM);
1146
// Hidden root may have data.
1147
if ( IS_VIRTUAL_ROOT(item) )
1149
return GET_VIRTUAL_ROOT()->GetData();
1153
if ( !DoGetItem(&tvItem) )
1158
wxTreeItemData *data = (wxTreeItemData *)tvItem.lParam;
1159
if ( IsDataIndirect(data) )
1161
data = ((wxTreeItemIndirectData *)data)->GetData();
1167
void wxTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data)
1169
wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1171
if ( IS_VIRTUAL_ROOT(item) )
1173
GET_VIRTUAL_ROOT()->SetData(data);
1176
// first, associate this piece of data with this item
1182
wxTreeViewItem tvItem(item, TVIF_PARAM);
1184
if ( HasIndirectData(item) )
1186
if ( DoGetItem(&tvItem) )
1188
((wxTreeItemIndirectData *)tvItem.lParam)->SetData(data);
1192
wxFAIL_MSG( wxT("failed to change tree items data") );
1197
tvItem.lParam = (LPARAM)data;
1202
void wxTreeCtrl::SetIndirectItemData(const wxTreeItemId& item,
1203
wxTreeItemIndirectData *data)
1205
// this should never happen because it's unnecessary and will probably lead
1206
// to crash too because the code elsewhere supposes that the pointer the
1207
// wxTreeItemIndirectData has is a real wxItemData and not
1208
// wxTreeItemIndirectData as well
1209
wxASSERT_MSG( !HasIndirectData(item), wxT("setting indirect data twice?") );
1211
SetItemData(item, data);
1214
bool wxTreeCtrl::HasIndirectData(const wxTreeItemId& item) const
1216
// query the item itself
1217
wxTreeViewItem tvItem(item, TVIF_PARAM);
1218
if ( !DoGetItem(&tvItem) )
1223
wxTreeItemData *data = (wxTreeItemData *)tvItem.lParam;
1225
return data && IsDataIndirect(data);
1228
void wxTreeCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
1230
wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1232
if ( IS_VIRTUAL_ROOT(item) )
1235
wxTreeViewItem tvItem(item, TVIF_CHILDREN);
1236
tvItem.cChildren = (int)has;
1240
void wxTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
1242
wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1244
if ( IS_VIRTUAL_ROOT(item) )
1247
wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_BOLD);
1248
tvItem.state = bold ? TVIS_BOLD : 0;
1252
void wxTreeCtrl::SetItemDropHighlight(const wxTreeItemId& item, bool highlight)
1254
if ( IS_VIRTUAL_ROOT(item) )
1257
wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_DROPHILITED);
1258
tvItem.state = highlight ? TVIS_DROPHILITED : 0;
1262
void wxTreeCtrl::RefreshItem(const wxTreeItemId& item)
1264
if ( IS_VIRTUAL_ROOT(item) )
1268
if ( GetBoundingRect(item, rect) )
1274
wxColour wxTreeCtrl::GetItemTextColour(const wxTreeItemId& item) const
1276
wxCHECK_MSG( item.IsOk(), wxNullColour, wxT("invalid tree item") );
1278
wxMapTreeAttr::const_iterator it = m_attrs.find(item.m_pItem);
1279
return it == m_attrs.end() ? wxNullColour : it->second->GetTextColour();
1282
wxColour wxTreeCtrl::GetItemBackgroundColour(const wxTreeItemId& item) const
1284
wxCHECK_MSG( item.IsOk(), wxNullColour, wxT("invalid tree item") );
1286
wxMapTreeAttr::const_iterator it = m_attrs.find(item.m_pItem);
1287
return it == m_attrs.end() ? wxNullColour : it->second->GetBackgroundColour();
1290
wxFont wxTreeCtrl::GetItemFont(const wxTreeItemId& item) const
1292
wxCHECK_MSG( item.IsOk(), wxNullFont, wxT("invalid tree item") );
1294
wxMapTreeAttr::const_iterator it = m_attrs.find(item.m_pItem);
1295
return it == m_attrs.end() ? wxNullFont : it->second->GetFont();
1298
void wxTreeCtrl::SetItemTextColour(const wxTreeItemId& item,
1299
const wxColour& col)
1301
wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1303
wxTreeItemAttr *attr;
1304
wxMapTreeAttr::iterator it = m_attrs.find(item.m_pItem);
1305
if ( it == m_attrs.end() )
1307
m_hasAnyAttr = true;
1309
m_attrs[item.m_pItem] =
1310
attr = new wxTreeItemAttr;
1317
attr->SetTextColour(col);
1322
void wxTreeCtrl::SetItemBackgroundColour(const wxTreeItemId& item,
1323
const wxColour& col)
1325
wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1327
wxTreeItemAttr *attr;
1328
wxMapTreeAttr::iterator it = m_attrs.find(item.m_pItem);
1329
if ( it == m_attrs.end() )
1331
m_hasAnyAttr = true;
1333
m_attrs[item.m_pItem] =
1334
attr = new wxTreeItemAttr;
1336
else // already in the hash
1341
attr->SetBackgroundColour(col);
1346
void wxTreeCtrl::SetItemFont(const wxTreeItemId& item, const wxFont& font)
1348
wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1350
wxTreeItemAttr *attr;
1351
wxMapTreeAttr::iterator it = m_attrs.find(item.m_pItem);
1352
if ( it == m_attrs.end() )
1354
m_hasAnyAttr = true;
1356
m_attrs[item.m_pItem] =
1357
attr = new wxTreeItemAttr;
1359
else // already in the hash
1364
attr->SetFont(font);
1369
// ----------------------------------------------------------------------------
1371
// ----------------------------------------------------------------------------
1373
bool wxTreeCtrl::IsVisible(const wxTreeItemId& item) const
1375
wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
1377
if ( item == wxTreeItemId(TVI_ROOT) )
1379
// virtual (hidden) root is never visible
1383
// Bug in Gnu-Win32 headers, so don't use the macro TreeView_GetItemRect
1386
// this ugliness comes directly from MSDN - it *is* the correct way to pass
1387
// the HTREEITEM with TVM_GETITEMRECT
1388
*(HTREEITEM *)&rect = HITEM(item);
1390
// true means to get rect for just the text, not the whole line
1391
if ( !::SendMessage(GetHwnd(), TVM_GETITEMRECT, true, (LPARAM)&rect) )
1393
// if TVM_GETITEMRECT returned false, then the item is definitely not
1394
// visible (because its parent is not expanded)
1398
// however if it returned true, the item might still be outside the
1399
// currently visible part of the tree, test for it (notice that partly
1400
// visible means visible here)
1401
return rect.bottom > 0 && rect.top < GetClientSize().y;
1404
bool wxTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const
1406
wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
1408
wxTreeViewItem tvItem(item, TVIF_CHILDREN);
1411
return tvItem.cChildren != 0;
1414
bool wxTreeCtrl::IsExpanded(const wxTreeItemId& item) const
1416
wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
1418
wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_EXPANDED);
1421
return (tvItem.state & TVIS_EXPANDED) != 0;
1424
bool wxTreeCtrl::IsSelected(const wxTreeItemId& item) const
1426
wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
1428
wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_SELECTED);
1431
return (tvItem.state & TVIS_SELECTED) != 0;
1434
bool wxTreeCtrl::IsBold(const wxTreeItemId& item) const
1436
wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
1438
wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_BOLD);
1441
return (tvItem.state & TVIS_BOLD) != 0;
1444
// ----------------------------------------------------------------------------
1446
// ----------------------------------------------------------------------------
1448
wxTreeItemId wxTreeCtrl::GetRootItem() const
1450
// Root may be real (visible) or virtual (hidden).
1451
if ( GET_VIRTUAL_ROOT() )
1454
return wxTreeItemId(TreeView_GetRoot(GetHwnd()));
1457
wxTreeItemId wxTreeCtrl::GetSelection() const
1459
wxCHECK_MSG( !(m_windowStyle & wxTR_MULTIPLE), wxTreeItemId(),
1460
wxT("this only works with single selection controls") );
1462
return wxTreeItemId(TreeView_GetSelection(GetHwnd()));
1465
wxTreeItemId wxTreeCtrl::GetItemParent(const wxTreeItemId& item) const
1467
wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1471
if ( IS_VIRTUAL_ROOT(item) )
1473
// no parent for the virtual root
1478
hItem = TreeView_GetParent(GetHwnd(), HITEM(item));
1479
if ( !hItem && HasFlag(wxTR_HIDE_ROOT) )
1481
// the top level items should have the virtual root as their parent
1486
return wxTreeItemId(hItem);
1489
wxTreeItemId wxTreeCtrl::GetFirstChild(const wxTreeItemId& item,
1490
wxTreeItemIdValue& cookie) const
1492
wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1494
// remember the last child returned in 'cookie'
1495
cookie = TreeView_GetChild(GetHwnd(), HITEM(item));
1497
return wxTreeItemId(cookie);
1500
wxTreeItemId wxTreeCtrl::GetNextChild(const wxTreeItemId& WXUNUSED(item),
1501
wxTreeItemIdValue& cookie) const
1503
wxTreeItemId fromCookie(cookie);
1505
HTREEITEM hitem = HITEM(fromCookie);
1507
hitem = TreeView_GetNextSibling(GetHwnd(), hitem);
1509
wxTreeItemId item(hitem);
1511
cookie = item.m_pItem;
1516
#if WXWIN_COMPATIBILITY_2_4
1518
wxTreeItemId wxTreeCtrl::GetFirstChild(const wxTreeItemId& item,
1521
wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1523
cookie = (long)TreeView_GetChild(GetHwnd(), HITEM(item));
1525
return wxTreeItemId((void *)cookie);
1528
wxTreeItemId wxTreeCtrl::GetNextChild(const wxTreeItemId& WXUNUSED(item),
1531
wxTreeItemId fromCookie((void *)cookie);
1533
HTREEITEM hitem = HITEM(fromCookie);
1535
hitem = TreeView_GetNextSibling(GetHwnd(), hitem);
1537
wxTreeItemId item(hitem);
1539
cookie = (long)item.m_pItem;
1544
#endif // WXWIN_COMPATIBILITY_2_4
1546
wxTreeItemId wxTreeCtrl::GetLastChild(const wxTreeItemId& item) const
1548
wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1550
// can this be done more efficiently?
1551
wxTreeItemIdValue cookie;
1553
wxTreeItemId childLast,
1554
child = GetFirstChild(item, cookie);
1555
while ( child.IsOk() )
1558
child = GetNextChild(item, cookie);
1564
wxTreeItemId wxTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
1566
wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1567
return wxTreeItemId(TreeView_GetNextSibling(GetHwnd(), HITEM(item)));
1570
wxTreeItemId wxTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const
1572
wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1573
return wxTreeItemId(TreeView_GetPrevSibling(GetHwnd(), HITEM(item)));
1576
wxTreeItemId wxTreeCtrl::GetFirstVisibleItem() const
1578
return wxTreeItemId(TreeView_GetFirstVisible(GetHwnd()));
1581
wxTreeItemId wxTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
1583
wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1584
wxASSERT_MSG( IsVisible(item), wxT("The item you call GetNextVisible() for must be visible itself!"));
1586
return wxTreeItemId(TreeView_GetNextVisible(GetHwnd(), HITEM(item)));
1589
wxTreeItemId wxTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
1591
wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1592
wxASSERT_MSG( IsVisible(item), wxT("The item you call GetPrevVisible() for must be visible itself!"));
1594
return wxTreeItemId(TreeView_GetPrevVisible(GetHwnd(), HITEM(item)));
1597
// ----------------------------------------------------------------------------
1598
// multiple selections emulation
1599
// ----------------------------------------------------------------------------
1601
bool wxTreeCtrl::IsItemChecked(const wxTreeItemId& item) const
1603
wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
1605
// receive the desired information.
1606
wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_STATEIMAGEMASK);
1609
// state image indices are 1 based
1610
return ((tvItem.state >> 12) - 1) == 1;
1613
void wxTreeCtrl::SetItemCheck(const wxTreeItemId& item, bool check)
1615
wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1617
// receive the desired information.
1618
wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_STATEIMAGEMASK);
1622
// state images are one-based
1623
tvItem.state = (check ? 2 : 1) << 12;
1628
size_t wxTreeCtrl::GetSelections(wxArrayTreeItemIds& selections) const
1630
TraverseSelections selector(this, selections);
1632
return selector.GetCount();
1635
// ----------------------------------------------------------------------------
1637
// ----------------------------------------------------------------------------
1639
wxTreeItemId wxTreeCtrl::DoInsertItem(const wxTreeItemId& parent,
1640
wxTreeItemId hInsertAfter,
1641
const wxString& text,
1642
int image, int selectedImage,
1643
wxTreeItemData *data)
1645
wxCHECK_MSG( parent.IsOk() || !TreeView_GetRoot(GetHwnd()),
1647
_T("can't have more than one root in the tree") );
1649
TV_INSERTSTRUCT tvIns;
1650
tvIns.hParent = HITEM(parent);
1651
tvIns.hInsertAfter = HITEM(hInsertAfter);
1653
// this is how we insert the item as the first child: supply a NULL
1655
if ( !tvIns.hInsertAfter )
1657
tvIns.hInsertAfter = TVI_FIRST;
1661
if ( !text.empty() )
1664
tvIns.item.pszText = (wxChar *)text.c_str(); // cast is ok
1668
tvIns.item.pszText = NULL;
1669
tvIns.item.cchTextMax = 0;
1675
tvIns.item.iImage = image;
1677
if ( selectedImage == -1 )
1679
// take the same image for selected icon if not specified
1680
selectedImage = image;
1684
if ( selectedImage != -1 )
1686
mask |= TVIF_SELECTEDIMAGE;
1687
tvIns.item.iSelectedImage = selectedImage;
1693
tvIns.item.lParam = (LPARAM)data;
1696
tvIns.item.mask = mask;
1698
HTREEITEM id = (HTREEITEM) TreeView_InsertItem(GetHwnd(), &tvIns);
1701
wxLogLastError(wxT("TreeView_InsertItem"));
1706
// associate the application tree item with Win32 tree item handle
1710
return wxTreeItemId(id);
1713
// for compatibility only
1714
#if WXWIN_COMPATIBILITY_2_4
1716
wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parent,
1717
const wxString& text,
1718
int image, int selImage,
1721
return DoInsertItem(parent, wxTreeItemId((void *)insertAfter), text,
1722
image, selImage, NULL);
1725
wxImageList *wxTreeCtrl::GetImageList(int) const
1727
return GetImageList();
1730
void wxTreeCtrl::SetImageList(wxImageList *imageList, int)
1732
SetImageList(imageList);
1735
int wxTreeCtrl::GetItemSelectedImage(const wxTreeItemId& item) const
1737
return GetItemImage(item, wxTreeItemIcon_Selected);
1740
void wxTreeCtrl::SetItemSelectedImage(const wxTreeItemId& item, int image)
1742
SetItemImage(item, image, wxTreeItemIcon_Selected);
1745
#endif // WXWIN_COMPATIBILITY_2_4
1747
wxTreeItemId wxTreeCtrl::AddRoot(const wxString& text,
1748
int image, int selectedImage,
1749
wxTreeItemData *data)
1752
if ( m_windowStyle & wxTR_HIDE_ROOT )
1754
// create a virtual root item, the parent for all the others
1755
m_pVirtualRoot = new wxVirtualNode(data);
1760
return DoInsertItem(wxTreeItemId(), wxTreeItemId(),
1761
text, image, selectedImage, data);
1764
wxTreeItemId wxTreeCtrl::PrependItem(const wxTreeItemId& parent,
1765
const wxString& text,
1766
int image, int selectedImage,
1767
wxTreeItemData *data)
1769
return DoInsertItem(parent, TVI_FIRST,
1770
text, image, selectedImage, data);
1773
wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parent,
1774
const wxTreeItemId& idPrevious,
1775
const wxString& text,
1776
int image, int selectedImage,
1777
wxTreeItemData *data)
1779
return DoInsertItem(parent, idPrevious, text, image, selectedImage, data);
1782
wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parent,
1784
const wxString& text,
1785
int image, int selectedImage,
1786
wxTreeItemData *data)
1788
// find the item from index
1789
wxTreeItemIdValue cookie;
1790
wxTreeItemId idPrev, idCur = GetFirstChild(parent, cookie);
1791
while ( index != 0 && idCur.IsOk() )
1796
idCur = GetNextChild(parent, cookie);
1799
// assert, not check: if the index is invalid, we will append the item
1801
wxASSERT_MSG( index == 0, _T("bad index in wxTreeCtrl::InsertItem") );
1803
return DoInsertItem(parent, idPrev, text, image, selectedImage, data);
1806
wxTreeItemId wxTreeCtrl::AppendItem(const wxTreeItemId& parent,
1807
const wxString& text,
1808
int image, int selectedImage,
1809
wxTreeItemData *data)
1811
return DoInsertItem(parent, TVI_LAST,
1812
text, image, selectedImage, data);
1815
void wxTreeCtrl::Delete(const wxTreeItemId& item)
1817
if ( !TreeView_DeleteItem(GetHwnd(), HITEM(item)) )
1819
wxLogLastError(wxT("TreeView_DeleteItem"));
1823
// delete all children (but don't delete the item itself)
1824
void wxTreeCtrl::DeleteChildren(const wxTreeItemId& item)
1826
wxTreeItemIdValue cookie;
1828
wxArrayTreeItemIds children;
1829
wxTreeItemId child = GetFirstChild(item, cookie);
1830
while ( child.IsOk() )
1832
children.Add(child);
1834
child = GetNextChild(item, cookie);
1837
size_t nCount = children.Count();
1838
for ( size_t n = 0; n < nCount; n++ )
1840
if ( !TreeView_DeleteItem(GetHwnd(), HITEM_PTR(children[n])) )
1842
wxLogLastError(wxT("TreeView_DeleteItem"));
1847
void wxTreeCtrl::DeleteAllItems()
1849
// delete the "virtual" root item.
1850
if ( GET_VIRTUAL_ROOT() )
1852
delete GET_VIRTUAL_ROOT();
1853
m_pVirtualRoot = NULL;
1856
// and all the real items
1858
if ( !TreeView_DeleteAllItems(GetHwnd()) )
1860
wxLogLastError(wxT("TreeView_DeleteAllItems"));
1864
void wxTreeCtrl::DoExpand(const wxTreeItemId& item, int flag)
1866
wxASSERT_MSG( flag == TVE_COLLAPSE ||
1867
flag == (TVE_COLLAPSE | TVE_COLLAPSERESET) ||
1868
flag == TVE_EXPAND ||
1870
wxT("Unknown flag in wxTreeCtrl::DoExpand") );
1872
// A hidden root can be neither expanded nor collapsed.
1873
wxCHECK_RET( !(m_windowStyle & wxTR_HIDE_ROOT) || (HITEM(item) != TVI_ROOT),
1874
wxT("Can't expand/collapse hidden root node!") )
1876
// TreeView_Expand doesn't send TVN_ITEMEXPAND(ING) messages, so we must
1877
// emulate them. This behaviour has changed slightly with comctl32.dll
1878
// v 4.70 - now it does send them but only the first time. To maintain
1879
// compatible behaviour and also in order to not have surprises with the
1880
// future versions, don't rely on this and still do everything ourselves.
1881
// To avoid that the messages be sent twice when the item is expanded for
1882
// the first time we must clear TVIS_EXPANDEDONCE style manually.
1884
wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_EXPANDEDONCE);
1888
if ( TreeView_Expand(GetHwnd(), HITEM(item), flag) != 0 )
1890
wxTreeEvent event(wxEVT_NULL, m_windowId);
1891
event.m_item = item;
1892
event.SetEventObject(this);
1894
// note that the {EXPAND|COLLAPS}ING event is sent by TreeView_Expand()
1896
event.SetEventType(gs_expandEvents[IsExpanded(item) ? IDX_EXPAND
1900
(void)GetEventHandler()->ProcessEvent(event);
1902
//else: change didn't took place, so do nothing at all
1905
void wxTreeCtrl::Expand(const wxTreeItemId& item)
1907
DoExpand(item, TVE_EXPAND);
1910
void wxTreeCtrl::Collapse(const wxTreeItemId& item)
1912
DoExpand(item, TVE_COLLAPSE);
1915
void wxTreeCtrl::CollapseAndReset(const wxTreeItemId& item)
1917
DoExpand(item, TVE_COLLAPSE | TVE_COLLAPSERESET);
1920
void wxTreeCtrl::Toggle(const wxTreeItemId& item)
1922
DoExpand(item, TVE_TOGGLE);
1925
#if WXWIN_COMPATIBILITY_2_4
1927
void wxTreeCtrl::ExpandItem(const wxTreeItemId& item, int action)
1929
DoExpand(item, action);
1934
void wxTreeCtrl::Unselect()
1936
wxASSERT_MSG( !(m_windowStyle & wxTR_MULTIPLE),
1937
wxT("doesn't make sense, may be you want UnselectAll()?") );
1939
// just remove the selection
1940
SelectItem(wxTreeItemId());
1943
void wxTreeCtrl::UnselectAll()
1945
if ( m_windowStyle & wxTR_MULTIPLE )
1947
wxArrayTreeItemIds selections;
1948
size_t count = GetSelections(selections);
1949
for ( size_t n = 0; n < count; n++ )
1951
#if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1952
SetItemCheck(HITEM_PTR(selections[n]), false);
1953
#else // !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1954
::UnselectItem(GetHwnd(), HITEM_PTR(selections[n]));
1955
#endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE/!wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1958
m_htSelStart.Unset();
1962
// just remove the selection
1967
void wxTreeCtrl::SelectItem(const wxTreeItemId& item, bool select)
1969
if ( m_windowStyle & wxTR_MULTIPLE )
1971
#if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1972
// selecting the item means checking it
1973
SetItemCheck(item, select);
1974
#else // !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1975
::SelectItem(GetHwnd(), HITEM(item), select);
1976
#endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE/!wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1980
wxASSERT_MSG( select,
1981
_T("SelectItem(false) works only for multiselect") );
1983
// inspite of the docs (MSDN Jan 99 edition), we don't seem to receive
1984
// the notification from the control (i.e. TVN_SELCHANG{ED|ING}), so
1985
// send them ourselves
1987
wxTreeEvent event(wxEVT_NULL, m_windowId);
1988
event.m_item = item;
1989
event.SetEventObject(this);
1991
event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGING);
1992
if ( !GetEventHandler()->ProcessEvent(event) || event.IsAllowed() )
1994
if ( !TreeView_SelectItem(GetHwnd(), HITEM(item)) )
1996
wxLogLastError(wxT("TreeView_SelectItem"));
2000
event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
2001
(void)GetEventHandler()->ProcessEvent(event);
2004
//else: program vetoed the change
2008
void wxTreeCtrl::UnselectItem(const wxTreeItemId& item)
2010
SelectItem(item, false);
2013
void wxTreeCtrl::ToggleItemSelection(const wxTreeItemId& item)
2015
SelectItem(item, !IsSelected(item));
2018
void wxTreeCtrl::EnsureVisible(const wxTreeItemId& item)
2021
TreeView_EnsureVisible(GetHwnd(), HITEM(item));
2024
void wxTreeCtrl::ScrollTo(const wxTreeItemId& item)
2026
if ( !TreeView_SelectSetFirstVisible(GetHwnd(), HITEM(item)) )
2028
wxLogLastError(wxT("TreeView_SelectSetFirstVisible"));
2032
wxTextCtrl *wxTreeCtrl::GetEditControl() const
2037
void wxTreeCtrl::DeleteTextCtrl()
2041
// the HWND corresponding to this control is deleted by the tree
2042
// control itself and we don't know when exactly this happens, so check
2043
// if the window still exists before calling UnsubclassWin()
2044
if ( !::IsWindow(GetHwndOf(m_textCtrl)) )
2046
m_textCtrl->SetHWND(0);
2049
m_textCtrl->UnsubclassWin();
2050
m_textCtrl->SetHWND(0);
2058
wxTextCtrl* wxTreeCtrl::EditLabel(const wxTreeItemId& item,
2059
wxClassInfo* textControlClass)
2061
wxASSERT( textControlClass->IsKindOf(CLASSINFO(wxTextCtrl)) );
2066
m_textCtrl = (wxTextCtrl *)textControlClass->CreateObject();
2067
HWND hWnd = (HWND) TreeView_EditLabel(GetHwnd(), HITEM(item));
2069
// this is not an error - the TVN_BEGINLABELEDIT handler might have
2078
// textctrl is subclassed in MSWOnNotify
2082
// End label editing, optionally cancelling the edit
2083
void wxTreeCtrl::DoEndEditLabel(bool discardChanges)
2085
TreeView_EndEditLabelNow(GetHwnd(), discardChanges);
2090
wxTreeItemId wxTreeCtrl::HitTest(const wxPoint& point, int& flags)
2092
TV_HITTESTINFO hitTestInfo;
2093
hitTestInfo.pt.x = (int)point.x;
2094
hitTestInfo.pt.y = (int)point.y;
2096
(void) TreeView_HitTest(GetHwnd(), &hitTestInfo);
2101
#define TRANSLATE_FLAG(flag) if ( hitTestInfo.flags & TVHT_##flag ) \
2102
flags |= wxTREE_HITTEST_##flag
2104
TRANSLATE_FLAG(ABOVE);
2105
TRANSLATE_FLAG(BELOW);
2106
TRANSLATE_FLAG(NOWHERE);
2107
TRANSLATE_FLAG(ONITEMBUTTON);
2108
TRANSLATE_FLAG(ONITEMICON);
2109
TRANSLATE_FLAG(ONITEMINDENT);
2110
TRANSLATE_FLAG(ONITEMLABEL);
2111
TRANSLATE_FLAG(ONITEMRIGHT);
2112
TRANSLATE_FLAG(ONITEMSTATEICON);
2113
TRANSLATE_FLAG(TOLEFT);
2114
TRANSLATE_FLAG(TORIGHT);
2116
#undef TRANSLATE_FLAG
2118
return wxTreeItemId(hitTestInfo.hItem);
2121
bool wxTreeCtrl::GetBoundingRect(const wxTreeItemId& item,
2123
bool textOnly) const
2127
// Virtual root items have no bounding rectangle
2128
if ( IS_VIRTUAL_ROOT(item) )
2133
if ( TreeView_GetItemRect(GetHwnd(), HITEM(item),
2136
rect = wxRect(wxPoint(rc.left, rc.top), wxPoint(rc.right, rc.bottom));
2142
// couldn't retrieve rect: for example, item isn't visible
2147
// ----------------------------------------------------------------------------
2149
// ----------------------------------------------------------------------------
2151
// this is just a tiny namespace which is friend to wxTreeCtrl and so can use
2152
// functions such as IsDataIndirect()
2153
class wxTreeSortHelper
2156
static int CALLBACK Compare(LPARAM data1, LPARAM data2, LPARAM tree);
2159
static wxTreeItemId GetIdFromData(wxTreeCtrl *tree, LPARAM item)
2161
wxTreeItemData *data = (wxTreeItemData *)item;
2162
if ( tree->IsDataIndirect(data) )
2164
data = ((wxTreeItemIndirectData *)data)->GetData();
2167
return data->GetId();
2171
int CALLBACK wxTreeSortHelper::Compare(LPARAM pItem1,
2175
wxCHECK_MSG( pItem1 && pItem2, 0,
2176
wxT("sorting tree without data doesn't make sense") );
2178
wxTreeCtrl *tree = (wxTreeCtrl *)htree;
2180
return tree->OnCompareItems(GetIdFromData(tree, pItem1),
2181
GetIdFromData(tree, pItem2));
2184
int wxTreeCtrl::OnCompareItems(const wxTreeItemId& item1,
2185
const wxTreeItemId& item2)
2187
return wxStrcmp(GetItemText(item1), GetItemText(item2));
2190
void wxTreeCtrl::SortChildren(const wxTreeItemId& item)
2192
wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
2194
// rely on the fact that TreeView_SortChildren does the same thing as our
2195
// default behaviour, i.e. sorts items alphabetically and so call it
2196
// directly if we're not in derived class (much more efficient!)
2197
if ( GetClassInfo() == CLASSINFO(wxTreeCtrl) )
2199
TreeView_SortChildren(GetHwnd(), HITEM(item), 0);
2204
tvSort.hParent = HITEM(item);
2205
tvSort.lpfnCompare = wxTreeSortHelper::Compare;
2206
tvSort.lParam = (LPARAM)this;
2207
TreeView_SortChildrenCB(GetHwnd(), &tvSort, 0 /* reserved */);
2211
// ----------------------------------------------------------------------------
2213
// ----------------------------------------------------------------------------
2215
bool wxTreeCtrl::MSWCommand(WXUINT cmd, WXWORD id)
2217
if ( cmd == EN_UPDATE )
2219
wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, id);
2220
event.SetEventObject( this );
2221
ProcessCommand(event);
2223
else if ( cmd == EN_KILLFOCUS )
2225
wxCommandEvent event(wxEVT_KILL_FOCUS, id);
2226
event.SetEventObject( this );
2227
ProcessCommand(event);
2235
// command processed
2239
// we hook into WndProc to process WM_MOUSEMOVE/WM_BUTTONUP messages - as we
2240
// only do it during dragging, minimize wxWin overhead (this is important for
2241
// WM_MOUSEMOVE as they're a lot of them) by catching Windows messages directly
2242
// instead of passing by wxWin events
2243
WXLRESULT wxTreeCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
2245
bool processed = false;
2247
bool isMultiple = HasFlag(wxTR_MULTIPLE);
2249
// This message is sent after a right-click, or when the "menu" key is pressed
2250
if ( nMsg == WM_CONTEXTMENU )
2252
int x = GET_X_LPARAM(lParam),
2253
y = GET_Y_LPARAM(lParam);
2254
// Convert the screen point to a client point
2255
wxPoint MenuPoint = ScreenToClient(wxPoint(x, y));
2257
wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_MENU, GetId() );
2259
// can't use GetSelection() here as it would assert in multiselect mode
2260
event.m_item = wxTreeItemId(TreeView_GetSelection(GetHwnd()));
2261
event.SetEventObject( this );
2263
// Get the bounding rectangle for the item, including the non-text areas
2265
GetBoundingRect(event.m_item, ItemRect, false);
2266
// If the point is inside the bounding rectangle, use it as the click position.
2267
// This should be the case for WM_CONTEXTMENU as the result of a right-click
2268
if (ItemRect.Inside(MenuPoint))
2270
event.m_pointDrag = MenuPoint;
2272
// Use the Explorer standard of putting the menu at the left edge of the text,
2273
// in the vertical middle of the text. Should be the case for the "menu" key
2276
// Use the bounding rectangle of only the text part
2277
GetBoundingRect(event.m_item, ItemRect, true);
2278
event.m_pointDrag = wxPoint(ItemRect.GetX(), ItemRect.GetY() + ItemRect.GetHeight() / 2);
2281
if ( GetEventHandler()->ProcessEvent(event) )
2283
//else: continue with generating wxEVT_CONTEXT_MENU in base class code
2285
else if ( (nMsg >= WM_MOUSEFIRST) && (nMsg <= WM_MOUSELAST) )
2287
// we only process mouse messages here and these parameters have the
2288
// same meaning for all of them
2289
int x = GET_X_LPARAM(lParam),
2290
y = GET_Y_LPARAM(lParam);
2291
HTREEITEM htItem = GetItemFromPoint(GetHwnd(), x, y);
2293
TV_HITTESTINFO tvht;
2297
(void) TreeView_HitTest(GetHwnd(), &tvht);
2301
case WM_RBUTTONDOWN:
2302
// if the item we are about to right click on is not already
2303
// selected or if we click outside of any item, remove the
2304
// entire previous selection
2305
if ( !htItem || !::IsItemSelected(GetHwnd(), htItem) )
2310
// select item and set the focus to the
2311
// newly selected item
2312
::SelectItem(GetHwnd(), htItem);
2313
::SetFocus(GetHwnd(), htItem);
2316
#if !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
2317
case WM_LBUTTONDOWN:
2318
if ( htItem && isMultiple && (tvht.flags & TVHT_ONITEM) != 0 )
2320
m_htClickedItem = (WXHTREEITEM) htItem;
2321
m_ptClick = wxPoint(x, y);
2323
if ( wParam & MK_CONTROL )
2327
// toggle selected state
2328
::ToggleItemSelection(GetHwnd(), htItem);
2330
::SetFocus(GetHwnd(), htItem);
2332
// reset on any click without Shift
2333
m_htSelStart.Unset();
2337
else if ( wParam & MK_SHIFT )
2339
// this selects all items between the starting one and
2342
if ( !m_htSelStart )
2344
// take the focused item
2345
m_htSelStart = TreeView_GetSelection(GetHwnd());
2349
SelectRange(GetHwnd(), HITEM(m_htSelStart), htItem,
2350
!(wParam & MK_CONTROL));
2352
::SelectItem(GetHwnd(), htItem);
2354
::SetFocus(GetHwnd(), htItem);
2358
else // normal click
2360
// avoid doing anything if we click on the only
2361
// currently selected item
2365
wxArrayTreeItemIds selections;
2366
size_t count = GetSelections(selections);
2369
HITEM_PTR(selections[0]) != htItem )
2371
// clear the previously selected items, if the
2372
// user clicked outside of the present selection.
2373
// otherwise, perform the deselection on mouse-up.
2374
// this allows multiple drag and drop to work.
2376
if (!IsItemSelected(GetHwnd(), htItem))
2380
// prevent the click from starting in-place editing
2381
// which should only happen if we click on the
2382
// already selected item (and nothing else is
2385
TreeView_SelectItem(GetHwnd(), 0);
2386
::SelectItem(GetHwnd(), htItem);
2388
::SetFocus(GetHwnd(), htItem);
2392
// reset on any click without Shift
2393
m_htSelStart.Unset();
2397
#endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
2401
if ( m_htClickedItem )
2403
int cx = abs(m_ptClick.x - x);
2404
int cy = abs(m_ptClick.y - y);
2406
if ( cx > GetSystemMetrics( SM_CXDRAG ) || cy > GetSystemMetrics( SM_CYDRAG ) )
2408
HWND pWnd = ::GetParent( GetHwnd() );
2413
tv.hdr.hwndFrom = GetHwnd();
2414
tv.hdr.idFrom = ::GetWindowLong( GetHwnd(), GWL_ID );
2415
tv.hdr.code = TVN_BEGINDRAG;
2417
tv.itemNew.hItem = HITEM(m_htClickedItem);
2420
ZeroMemory(&tviAux, sizeof(tviAux));
2421
tviAux.hItem = HITEM(m_htClickedItem);
2422
tviAux.mask = TVIF_STATE | TVIF_PARAM;
2423
tviAux.stateMask = 0xffffffff;
2424
TreeView_GetItem( GetHwnd(), &tviAux );
2426
tv.itemNew.state = tviAux.state;
2427
tv.itemNew.lParam = tviAux.lParam;
2432
::SendMessage( pWnd, WM_NOTIFY, tv.hdr.idFrom, (LPARAM)&tv );
2434
m_htClickedItem.Unset();
2437
#endif // __WXWINCE__
2441
m_dragImage->Move(wxPoint(x, y));
2444
// highlight the item as target (hiding drag image is
2445
// necessary - otherwise the display will be corrupted)
2446
m_dragImage->Hide();
2447
TreeView_SelectDropTarget(GetHwnd(), htItem);
2448
m_dragImage->Show();
2455
// facilitates multiple drag-and-drop
2456
if (htItem && isMultiple)
2458
wxArrayTreeItemIds selections;
2459
size_t count = GetSelections(selections);
2462
!(wParam & MK_CONTROL) &&
2463
!(wParam & MK_SHIFT))
2466
TreeView_SelectItem(GetHwnd(), htItem);
2467
::SelectItem(GetHwnd(), htItem);
2468
::SetFocus(GetHwnd(), htItem);
2470
m_htClickedItem.Unset();
2478
m_dragImage->EndDrag();
2482
// generate the drag end event
2483
wxTreeEvent event(wxEVT_COMMAND_TREE_END_DRAG, m_windowId);
2485
event.m_item = htItem;
2486
event.m_pointDrag = wxPoint(x, y);
2487
event.SetEventObject(this);
2489
(void)GetEventHandler()->ProcessEvent(event);
2491
// if we don't do it, the tree seems to think that 2 items
2492
// are selected simultaneously which is quite weird
2493
TreeView_SelectDropTarget(GetHwnd(), 0);
2498
#if !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
2499
else if ( (nMsg == WM_SETFOCUS || nMsg == WM_KILLFOCUS) && isMultiple )
2501
// the tree control greys out the selected item when it loses focus and
2502
// paints it as selected again when it regains it, but it won't do it
2503
// for the other items itself - help it
2504
wxArrayTreeItemIds selections;
2505
size_t count = GetSelections(selections);
2507
for ( size_t n = 0; n < count; n++ )
2509
// TreeView_GetItemRect() will return false if item is not visible,
2510
// which may happen perfectly well
2511
if ( TreeView_GetItemRect(GetHwnd(), HITEM_PTR(selections[n]),
2514
::InvalidateRect(GetHwnd(), &rect, FALSE);
2518
else if ( nMsg == WM_KEYDOWN && isMultiple )
2520
bool bCtrl = wxIsCtrlDown(),
2521
bShift = wxIsShiftDown();
2523
HTREEITEM htSel = (HTREEITEM)TreeView_GetSelection(GetHwnd());
2529
::ToggleItemSelection(GetHwnd(), htSel);
2535
::SelectItem(GetHwnd(), htSel);
2543
if ( !bCtrl && !bShift )
2545
// no modifiers, just clear selection and then let the default
2546
// processing to take place
2551
(void)wxControl::MSWWindowProc(nMsg, wParam, lParam);
2553
HTREEITEM htNext = (HTREEITEM)
2554
TreeView_GetNextItem
2558
wParam == VK_UP ? TVGN_PREVIOUSVISIBLE
2564
// at the top/bottom
2570
if ( !m_htSelStart )
2571
m_htSelStart = htSel;
2573
SelectRange(GetHwnd(), HITEM(m_htSelStart), htNext);
2577
// without changing selection
2578
::SetFocus(GetHwnd(), htNext);
2589
// TODO: handle Shift/Ctrl with these keys
2590
if ( !bCtrl && !bShift )
2594
m_htSelStart.Unset();
2598
#endif // !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
2599
else if ( nMsg == WM_COMMAND )
2601
// if we receive a EN_KILLFOCUS command from the in-place edit control
2602
// used for label editing, make sure to end editing
2605
UnpackCommand(wParam, lParam, &id, &hwnd, &cmd);
2607
if ( cmd == EN_KILLFOCUS )
2609
if ( m_textCtrl && m_textCtrl->GetHandle() == hwnd )
2619
rc = wxControl::MSWWindowProc(nMsg, wParam, lParam);
2625
wxTreeCtrl::MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
2627
// default WM_RBUTTONDOWN handler enters modal loop inside DefWindowProc()
2628
// waiting for WM_RBUTTONUP and then sends the resulting WM_CONTEXTMENU to
2629
// the parent window, not us, which completely breaks everything so simply
2630
// don't let it see this message at all
2631
if ( nMsg == WM_RBUTTONDOWN )
2634
// but because of the above we don't get NM_RCLICK which is normally
2635
// generated by tree window proc when the modal loop mentioned above ends
2636
// because the mouse is released -- synthesize it ourselves instead
2637
if ( nMsg == WM_RBUTTONUP )
2640
hdr.hwndFrom = GetHwnd();
2641
hdr.idFrom = GetId();
2642
hdr.code = NM_RCLICK;
2645
MSWOnNotify(GetId(), (LPARAM)&hdr, &rc);
2647
// continue as usual
2650
if ( nMsg == WM_CHAR )
2652
// also don't let the control process Space and Return keys because it
2653
// doesn't do anything useful with them anyhow but always beeps
2654
// annoyingly when it receives them and there is no way to turn it off
2655
// simply if you just process TREEITEM_ACTIVATED event to which Space
2656
// and Enter presses are mapped in your code
2657
if ( wParam == VK_SPACE || wParam == VK_RETURN )
2661
return wxControl::MSWDefWindowProc(nMsg, wParam, lParam);
2664
// process WM_NOTIFY Windows message
2665
bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
2667
wxTreeEvent event(wxEVT_NULL, m_windowId);
2668
wxEventType eventType = wxEVT_NULL;
2669
NMHDR *hdr = (NMHDR *)lParam;
2671
switch ( hdr->code )
2674
eventType = wxEVT_COMMAND_TREE_BEGIN_DRAG;
2677
case TVN_BEGINRDRAG:
2679
if ( eventType == wxEVT_NULL )
2680
eventType = wxEVT_COMMAND_TREE_BEGIN_RDRAG;
2681
//else: left drag, already set above
2683
NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
2685
event.m_item = tv->itemNew.hItem;
2686
event.m_pointDrag = wxPoint(tv->ptDrag.x, tv->ptDrag.y);
2688
// don't allow dragging by default: the user code must
2689
// explicitly say that it wants to allow it to avoid breaking
2695
case TVN_BEGINLABELEDIT:
2697
eventType = wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT;
2698
TV_DISPINFO *info = (TV_DISPINFO *)lParam;
2700
// although the user event handler may still veto it, it is
2701
// important to set it now so that calls to SetItemText() from
2702
// the event handler would change the text controls contents
2704
event.m_item = info->item.hItem;
2705
event.m_label = info->item.pszText;
2706
event.m_editCancelled = false;
2710
case TVN_DELETEITEM:
2712
eventType = wxEVT_COMMAND_TREE_DELETE_ITEM;
2713
NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
2715
event.m_item = tv->itemOld.hItem;
2719
wxMapTreeAttr::iterator it = m_attrs.find(tv->itemOld.hItem);
2720
if ( it != m_attrs.end() )
2729
case TVN_ENDLABELEDIT:
2731
eventType = wxEVT_COMMAND_TREE_END_LABEL_EDIT;
2732
TV_DISPINFO *info = (TV_DISPINFO *)lParam;
2734
event.m_item = info->item.hItem;
2735
event.m_label = info->item.pszText;
2736
event.m_editCancelled = info->item.pszText == NULL;
2741
// These *must* not be removed or TVN_GETINFOTIP will
2742
// not be processed each time the mouse is moved
2743
// and the tooltip will only ever update once.
2752
#ifdef TVN_GETINFOTIP
2753
case TVN_GETINFOTIP:
2755
eventType = wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP;
2756
NMTVGETINFOTIP *info = (NMTVGETINFOTIP*)lParam;
2758
// Which item are we trying to get a tooltip for?
2759
event.m_item = info->hItem;
2766
case TVN_GETDISPINFO:
2767
eventType = wxEVT_COMMAND_TREE_GET_INFO;
2770
case TVN_SETDISPINFO:
2772
if ( eventType == wxEVT_NULL )
2773
eventType = wxEVT_COMMAND_TREE_SET_INFO;
2774
//else: get, already set above
2776
TV_DISPINFO *info = (TV_DISPINFO *)lParam;
2778
event.m_item = info->item.hItem;
2782
case TVN_ITEMEXPANDING:
2783
case TVN_ITEMEXPANDED:
2785
NM_TREEVIEW* tv = (NM_TREEVIEW*)lParam;
2788
switch ( tv->action )
2791
wxLogDebug(wxT("unexpected code %d in TVN_ITEMEXPAND message"), tv->action);
2799
what = IDX_COLLAPSE;
2803
int how = hdr->code == TVN_ITEMEXPANDING ? IDX_DOING
2806
eventType = gs_expandEvents[what][how];
2808
event.m_item = tv->itemNew.hItem;
2814
eventType = wxEVT_COMMAND_TREE_KEY_DOWN;
2815
TV_KEYDOWN *info = (TV_KEYDOWN *)lParam;
2817
// fabricate the lParam and wParam parameters sufficiently
2818
// similar to the ones from a "real" WM_KEYDOWN so that
2819
// CreateKeyEvent() works correctly
2820
const bool isAltDown = ::GetKeyState(VK_MENU) < 0;
2821
WXLPARAM lParam = (isAltDown ? KF_ALTDOWN : 0) << 16;
2823
WXWPARAM wParam = info->wVKey;
2825
int keyCode = wxCharCodeMSWToWX(info->wVKey);
2828
// wxCharCodeMSWToWX() returns 0 to indicate that this is a
2833
event.m_evtKey = CreateKeyEvent(wxEVT_KEY_DOWN,
2838
// a separate event for Space/Return
2839
if ( !wxIsCtrlDown() && !wxIsShiftDown() && !isAltDown &&
2840
((info->wVKey == VK_SPACE) || (info->wVKey == VK_RETURN)) )
2842
wxTreeEvent event2(wxEVT_COMMAND_TREE_ITEM_ACTIVATED,
2844
event2.SetEventObject(this);
2845
if ( !(GetWindowStyle() & wxTR_MULTIPLE) )
2847
event2.m_item = GetSelection();
2849
//else: don't know how to get it
2851
(void)GetEventHandler()->ProcessEvent(event2);
2856
// NB: MSLU is broken and sends TVN_SELCHANGEDA instead of
2857
// TVN_SELCHANGEDW in Unicode mode under Win98. Therefore
2858
// we have to handle both messages:
2859
case TVN_SELCHANGEDA:
2860
case TVN_SELCHANGEDW:
2861
eventType = wxEVT_COMMAND_TREE_SEL_CHANGED;
2864
case TVN_SELCHANGINGA:
2865
case TVN_SELCHANGINGW:
2867
if ( eventType == wxEVT_NULL )
2868
eventType = wxEVT_COMMAND_TREE_SEL_CHANGING;
2869
//else: already set above
2871
if (hdr->code == TVN_SELCHANGINGW ||
2872
hdr->code == TVN_SELCHANGEDW)
2874
NM_TREEVIEWW* tv = (NM_TREEVIEWW *)lParam;
2875
event.m_item = tv->itemNew.hItem;
2876
event.m_itemOld = tv->itemOld.hItem;
2880
NM_TREEVIEWA* tv = (NM_TREEVIEWA *)lParam;
2881
event.m_item = tv->itemNew.hItem;
2882
event.m_itemOld = tv->itemOld.hItem;
2887
// instead of explicitly checking for _WIN32_IE, check if the
2888
// required symbols are available in the headers
2889
#if defined(CDDS_PREPAINT) && !wxUSE_COMCTL32_SAFELY
2892
LPNMTVCUSTOMDRAW lptvcd = (LPNMTVCUSTOMDRAW)lParam;
2893
NMCUSTOMDRAW& nmcd = lptvcd->nmcd;
2894
switch ( nmcd.dwDrawStage )
2897
// if we've got any items with non standard attributes,
2898
// notify us before painting each item
2899
*result = m_hasAnyAttr ? CDRF_NOTIFYITEMDRAW
2903
case CDDS_ITEMPREPAINT:
2905
wxMapTreeAttr::iterator
2906
it = m_attrs.find((void *)nmcd.dwItemSpec);
2908
if ( it == m_attrs.end() )
2910
// nothing to do for this item
2911
*result = CDRF_DODEFAULT;
2915
wxTreeItemAttr * const attr = it->second;
2917
// selection colours should override ours,
2918
// otherwise it is too confusing ot the user
2919
if ( !(nmcd.uItemState & CDIS_SELECTED) )
2922
if ( attr->HasBackgroundColour() )
2924
colBack = attr->GetBackgroundColour();
2925
lptvcd->clrTextBk = wxColourToRGB(colBack);
2929
// but we still want to keep the special foreground
2930
// colour when we don't have focus (we can't keep
2931
// it when we do, it would usually be unreadable on
2932
// the almost inverted bg colour...)
2933
if ( !(nmcd.uItemState & CDIS_SELECTED) ||
2934
FindFocus() != this )
2937
if ( attr->HasTextColour() )
2939
colText = attr->GetTextColour();
2940
lptvcd->clrText = wxColourToRGB(colText);
2944
if ( attr->HasFont() )
2946
HFONT hFont = GetHfontOf(attr->GetFont());
2948
::SelectObject(nmcd.hdc, hFont);
2950
*result = CDRF_NEWFONT;
2952
else // no specific font
2954
*result = CDRF_DODEFAULT;
2960
*result = CDRF_DODEFAULT;
2964
// we always process it
2966
#endif // have owner drawn support in headers
2970
DWORD pos = GetMessagePos();
2972
point.x = LOWORD(pos);
2973
point.y = HIWORD(pos);
2974
::MapWindowPoints(HWND_DESKTOP, GetHwnd(), &point, 1);
2976
wxTreeItemId item = HitTest(wxPoint(point.x, point.y), flags);
2977
if (flags & wxTREE_HITTEST_ONITEMSTATEICON)
2979
event.m_item = item;
2980
eventType = wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK;
2988
TV_HITTESTINFO tvhti;
2989
::GetCursorPos(&tvhti.pt);
2990
::ScreenToClient(GetHwnd(), &tvhti.pt);
2991
if ( TreeView_HitTest(GetHwnd(), &tvhti) )
2993
if ( tvhti.flags & TVHT_ONITEM )
2995
event.m_item = tvhti.hItem;
2996
eventType = (int)hdr->code == NM_DBLCLK
2997
? wxEVT_COMMAND_TREE_ITEM_ACTIVATED
2998
: wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK;
3000
event.m_pointDrag.x = tvhti.pt.x;
3001
event.m_pointDrag.y = tvhti.pt.y;
3010
return wxControl::MSWOnNotify(idCtrl, lParam, result);
3013
event.SetEventObject(this);
3014
event.SetEventType(eventType);
3016
bool processed = GetEventHandler()->ProcessEvent(event);
3019
switch ( hdr->code )
3022
// we translate NM_DBLCLK into ACTIVATED event, so don't interpret
3023
// the return code of this event handler as the return value for
3024
// NM_DBLCLK - otherwise, double clicking the item to toggle its
3025
// expanded status would never work
3030
case TVN_BEGINRDRAG:
3031
if ( event.IsAllowed() )
3033
// normally this is impossible because the m_dragImage is
3034
// deleted once the drag operation is over
3035
wxASSERT_MSG( !m_dragImage, _T("starting to drag once again?") );
3037
m_dragImage = new wxDragImage(*this, event.m_item);
3038
m_dragImage->BeginDrag(wxPoint(0,0), this);
3039
m_dragImage->Show();
3043
case TVN_DELETEITEM:
3045
// NB: we might process this message using wxWidgets event
3046
// tables, but due to overhead of wxWin event system we
3047
// prefer to do it here ourself (otherwise deleting a tree
3048
// with many items is just too slow)
3049
NM_TREEVIEW* tv = (NM_TREEVIEW *)lParam;
3051
wxTreeItemId item = event.m_item;
3052
if ( HasIndirectData(item) )
3054
wxTreeItemIndirectData *data = (wxTreeItemIndirectData *)
3056
delete data; // can't be NULL here
3060
wxTreeItemData *data = (wxTreeItemData *)tv->itemOld.lParam;
3061
delete data; // may be NULL, ok
3064
processed = true; // Make sure we don't get called twice
3068
case TVN_BEGINLABELEDIT:
3069
// return true to cancel label editing
3070
*result = !event.IsAllowed();
3072
// set ES_WANTRETURN ( like we do in BeginLabelEdit )
3073
if ( event.IsAllowed() )
3075
HWND hText = TreeView_GetEditControl(GetHwnd());
3078
// MBN: if m_textCtrl already has an HWND, it is a stale
3079
// pointer from a previous edit (because the user
3080
// didn't modify the label before dismissing the control,
3081
// and TVN_ENDLABELEDIT was not sent), so delete it
3082
if(m_textCtrl && m_textCtrl->GetHWND() != 0)
3085
m_textCtrl = new wxTextCtrl();
3086
m_textCtrl->SetParent(this);
3087
m_textCtrl->SetHWND((WXHWND)hText);
3088
m_textCtrl->SubclassWin((WXHWND)hText);
3090
// set wxTE_PROCESS_ENTER style for the text control to
3091
// force it to process the Enter presses itself, otherwise
3092
// they could be stolen from it by the dialog
3094
m_textCtrl->SetWindowStyle(m_textCtrl->GetWindowStyle()
3095
| wxTE_PROCESS_ENTER);
3098
else // we had set m_idEdited before
3104
case TVN_ENDLABELEDIT:
3105
// return true to set the label to the new string: note that we
3106
// also must pretend that we did process the message or it is going
3107
// to be passed to DefWindowProc() which will happily return false
3108
// cancelling the label change
3109
*result = event.IsAllowed();
3112
// ensure that we don't have the text ctrl which is going to be
3118
#ifdef TVN_GETINFOTIP
3119
case TVN_GETINFOTIP:
3121
// If the user permitted a tooltip change, change it
3122
if (event.IsAllowed())
3124
SetToolTip(event.m_label);
3131
case TVN_SELCHANGING:
3132
case TVN_ITEMEXPANDING:
3133
// return true to prevent the action from happening
3134
*result = !event.IsAllowed();
3137
case TVN_ITEMEXPANDED:
3138
// the item is not refreshed properly after expansion when it has
3139
// an image depending on the expanded/collapsed state - bug in
3140
// comctl32.dll or our code?
3142
NM_TREEVIEW* tv = (NM_TREEVIEW *)lParam;
3143
wxTreeItemId id(tv->itemNew.hItem);
3145
int image = GetItemImage(id, wxTreeItemIcon_Expanded);
3153
case TVN_GETDISPINFO:
3154
// NB: so far the user can't set the image himself anyhow, so do it
3155
// anyway - but this may change later
3156
//if ( /* !processed && */ 1 )
3158
wxTreeItemId item = event.m_item;
3159
TV_DISPINFO *info = (TV_DISPINFO *)lParam;
3160
if ( info->item.mask & TVIF_IMAGE )
3163
DoGetItemImageFromData
3166
IsExpanded(item) ? wxTreeItemIcon_Expanded
3167
: wxTreeItemIcon_Normal
3170
if ( info->item.mask & TVIF_SELECTEDIMAGE )
3172
info->item.iSelectedImage =
3173
DoGetItemImageFromData
3176
IsExpanded(item) ? wxTreeItemIcon_SelectedExpanded
3177
: wxTreeItemIcon_Selected
3184
// for the other messages the return value is ignored and there is
3185
// nothing special to do
3190
// ----------------------------------------------------------------------------
3192
// ----------------------------------------------------------------------------
3194
// why do they define INDEXTOSTATEIMAGEMASK but not the inverse?
3195
#define STATEIMAGEMASKTOINDEX(state) (((state) & TVIS_STATEIMAGEMASK) >> 12)
3197
void wxTreeCtrl::SetState(const wxTreeItemId& node, int state)
3200
tvi.hItem = (HTREEITEM)node.m_pItem;
3201
tvi.mask = TVIF_STATE;
3202
tvi.stateMask = TVIS_STATEIMAGEMASK;
3204
// Select the specified state, or -1 == cycle to the next one.
3207
TreeView_GetItem(GetHwnd(), &tvi);
3209
state = STATEIMAGEMASKTOINDEX(tvi.state) + 1;
3210
if ( state == m_imageListState->GetImageCount() )
3214
wxCHECK_RET( state < m_imageListState->GetImageCount(),
3215
_T("wxTreeCtrl::SetState(): item index out of bounds") );
3217
tvi.state = INDEXTOSTATEIMAGEMASK(state);
3219
TreeView_SetItem(GetHwnd(), &tvi);
3222
int wxTreeCtrl::GetState(const wxTreeItemId& node)
3225
tvi.hItem = (HTREEITEM)node.m_pItem;
3226
tvi.mask = TVIF_STATE;
3227
tvi.stateMask = TVIS_STATEIMAGEMASK;
3228
TreeView_GetItem(GetHwnd(), &tvi);
3230
return STATEIMAGEMASKTOINDEX(tvi.state);
3233
#if WXWIN_COMPATIBILITY_2_2
3235
wxTreeItemId wxTreeCtrl::GetParent(const wxTreeItemId& item) const
3237
return GetItemParent( item );
3240
#endif // WXWIN_COMPATIBILITY_2_2
3242
#endif // wxUSE_TREECTRL