1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: generic tree control implementation
4 // Author: Robert Roebling
6 // Modified: 22/10/98 - almost total rewrite, simpler interface (VZ)
8 // Copyright: (c) 1998 Robert Roebling and Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // =============================================================================
14 // =============================================================================
16 // -----------------------------------------------------------------------------
18 // -----------------------------------------------------------------------------
20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
21 #pragma implementation "treectlg.h"
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
33 #include "wx/treebase.h"
34 #include "wx/generic/treectlg.h"
36 #include "wx/textctrl.h"
37 #include "wx/imaglist.h"
38 #include "wx/settings.h"
39 #include "wx/dcclient.h"
41 #include "wx/renderer.h"
44 #include "wx/mac/private.h"
47 // -----------------------------------------------------------------------------
49 // -----------------------------------------------------------------------------
51 class WXDLLEXPORT wxGenericTreeItem
;
53 WX_DEFINE_EXPORTED_ARRAY_PTR(wxGenericTreeItem
*, wxArrayGenericTreeItems
);
55 // ----------------------------------------------------------------------------
57 // ----------------------------------------------------------------------------
59 static const int NO_IMAGE
= -1;
61 static const int PIXELS_PER_UNIT
= 10;
63 // -----------------------------------------------------------------------------
65 // -----------------------------------------------------------------------------
67 // timer used for enabling in-place edit
68 class WXDLLEXPORT wxTreeRenameTimer
: public wxTimer
71 // start editing the current item after half a second (if the mouse hasn't
72 // been clicked/moved)
75 wxTreeRenameTimer( wxGenericTreeCtrl
*owner
);
77 virtual void Notify();
80 wxGenericTreeCtrl
*m_owner
;
82 DECLARE_NO_COPY_CLASS(wxTreeRenameTimer
)
85 // control used for in-place edit
86 class WXDLLEXPORT wxTreeTextCtrl
: public wxTextCtrl
89 wxTreeTextCtrl(wxGenericTreeCtrl
*owner
, wxGenericTreeItem
*item
);
94 m_owner
->OnRenameCancelled(m_itemEdited
);
96 const wxGenericTreeItem
* item() const { return m_itemEdited
; }
99 void OnChar( wxKeyEvent
&event
);
100 void OnKeyUp( wxKeyEvent
&event
);
101 void OnKillFocus( wxFocusEvent
&event
);
103 bool AcceptChanges();
107 wxGenericTreeCtrl
*m_owner
;
108 wxGenericTreeItem
*m_itemEdited
;
109 wxString m_startValue
;
112 DECLARE_EVENT_TABLE()
113 DECLARE_NO_COPY_CLASS(wxTreeTextCtrl
)
116 // timer used to clear wxGenericTreeCtrl::m_findPrefix if no key was pressed
117 // for a sufficiently long time
118 class WXDLLEXPORT wxTreeFindTimer
: public wxTimer
121 // reset the current prefix after half a second of inactivity
122 enum { DELAY
= 500 };
124 wxTreeFindTimer( wxGenericTreeCtrl
*owner
) { m_owner
= owner
; }
126 virtual void Notify() { m_owner
->m_findPrefix
.clear(); }
129 wxGenericTreeCtrl
*m_owner
;
131 DECLARE_NO_COPY_CLASS(wxTreeFindTimer
)
135 class WXDLLEXPORT wxGenericTreeItem
139 wxGenericTreeItem() { m_data
= NULL
; }
140 wxGenericTreeItem( wxGenericTreeItem
*parent
,
141 const wxString
& text
,
144 wxTreeItemData
*data
);
146 ~wxGenericTreeItem();
149 wxArrayGenericTreeItems
& GetChildren() { return m_children
; }
151 const wxString
& GetText() const { return m_text
; }
152 int GetImage(wxTreeItemIcon which
= wxTreeItemIcon_Normal
) const
153 { return m_images
[which
]; }
154 wxTreeItemData
*GetData() const { return m_data
; }
156 // returns the current image for the item (depending on its
157 // selected/expanded/whatever state)
158 int GetCurrentImage() const;
160 void SetText( const wxString
&text
);
161 void SetImage(int image
, wxTreeItemIcon which
) { m_images
[which
] = image
; }
162 void SetData(wxTreeItemData
*data
) { m_data
= data
; }
164 void SetHasPlus(bool has
= true) { m_hasPlus
= has
; }
166 void SetBold(bool bold
) { m_isBold
= bold
; }
168 int GetX() const { return m_x
; }
169 int GetY() const { return m_y
; }
171 void SetX(int x
) { m_x
= x
; }
172 void SetY(int y
) { m_y
= y
; }
174 int GetHeight() const { return m_height
; }
175 int GetWidth() const { return m_width
; }
177 void SetHeight(int h
) { m_height
= h
; }
178 void SetWidth(int w
) { m_width
= w
; }
180 wxGenericTreeItem
*GetParent() const { return m_parent
; }
183 // deletes all children notifying the treectrl about it if !NULL
185 void DeleteChildren(wxGenericTreeCtrl
*tree
= NULL
);
187 // get count of all children (and grand children if 'recursively')
188 size_t GetChildrenCount(bool recursively
= true) const;
190 void Insert(wxGenericTreeItem
*child
, size_t index
)
191 { m_children
.Insert(child
, index
); }
193 void GetSize( int &x
, int &y
, const wxGenericTreeCtrl
* );
195 // return the item at given position (or NULL if no item), onButton is
196 // true if the point belongs to the item's button, otherwise it lies
197 // on the item's label
198 wxGenericTreeItem
*HitTest( const wxPoint
& point
,
199 const wxGenericTreeCtrl
*,
203 void Expand() { m_isCollapsed
= false; }
204 void Collapse() { m_isCollapsed
= true; }
206 void SetHilight( bool set
= true ) { m_hasHilight
= set
; }
209 bool HasChildren() const { return !m_children
.IsEmpty(); }
210 bool IsSelected() const { return m_hasHilight
!= 0; }
211 bool IsExpanded() const { return !m_isCollapsed
; }
212 bool HasPlus() const { return m_hasPlus
|| HasChildren(); }
213 bool IsBold() const { return m_isBold
!= 0; }
216 // get them - may be NULL
217 wxTreeItemAttr
*GetAttributes() const { return m_attr
; }
218 // get them ensuring that the pointer is not NULL
219 wxTreeItemAttr
& Attr()
223 m_attr
= new wxTreeItemAttr
;
229 void SetAttributes(wxTreeItemAttr
*attr
)
231 if ( m_ownsAttr
) delete m_attr
;
235 // set them and delete when done
236 void AssignAttributes(wxTreeItemAttr
*attr
)
243 // since there can be very many of these, we save size by chosing
244 // the smallest representation for the elements and by ordering
245 // the members to avoid padding.
246 wxString m_text
; // label to be rendered for item
248 wxTreeItemData
*m_data
; // user-provided data
250 wxArrayGenericTreeItems m_children
; // list of children
251 wxGenericTreeItem
*m_parent
; // parent of this item
253 wxTreeItemAttr
*m_attr
; // attributes???
255 // tree ctrl images for the normal, selected, expanded and
256 // expanded+selected states
257 int m_images
[wxTreeItemIcon_Max
];
259 wxCoord m_x
; // (virtual) offset from top
260 wxCoord m_y
; // (virtual) offset from left
261 int m_width
; // width of this item
262 int m_height
; // height of this item
264 // use bitfields to save size
265 int m_isCollapsed
:1;
266 int m_hasHilight
:1; // same as focused
267 int m_hasPlus
:1; // used for item which doesn't have
268 // children but has a [+] button
269 int m_isBold
:1; // render the label in bold font
270 int m_ownsAttr
:1; // delete attribute when done
272 DECLARE_NO_COPY_CLASS(wxGenericTreeItem
)
275 // =============================================================================
277 // =============================================================================
279 // ----------------------------------------------------------------------------
281 // ----------------------------------------------------------------------------
283 // translate the key or mouse event flags to the type of selection we're
285 static void EventFlagsToSelType(long style
,
289 bool &extended_select
,
290 bool &unselect_others
)
292 is_multiple
= (style
& wxTR_MULTIPLE
) != 0;
293 extended_select
= shiftDown
&& is_multiple
;
294 unselect_others
= !(extended_select
|| (ctrlDown
&& is_multiple
));
297 // check if the given item is under another one
298 static bool IsDescendantOf(const wxGenericTreeItem
*parent
, const wxGenericTreeItem
*item
)
302 if ( item
== parent
)
304 // item is a descendant of parent
308 item
= item
->GetParent();
314 // -----------------------------------------------------------------------------
315 // wxTreeRenameTimer (internal)
316 // -----------------------------------------------------------------------------
318 wxTreeRenameTimer
::wxTreeRenameTimer( wxGenericTreeCtrl
*owner
)
323 void wxTreeRenameTimer
::Notify()
325 m_owner
->OnRenameTimer();
328 //-----------------------------------------------------------------------------
329 // wxTreeTextCtrl (internal)
330 //-----------------------------------------------------------------------------
332 BEGIN_EVENT_TABLE(wxTreeTextCtrl
,wxTextCtrl
)
333 EVT_CHAR (wxTreeTextCtrl
::OnChar
)
334 EVT_KEY_UP (wxTreeTextCtrl
::OnKeyUp
)
335 EVT_KILL_FOCUS (wxTreeTextCtrl
::OnKillFocus
)
338 wxTreeTextCtrl
::wxTreeTextCtrl(wxGenericTreeCtrl
*owner
,
339 wxGenericTreeItem
*item
)
340 : m_itemEdited(item
), m_startValue(item
->GetText())
345 int w
= m_itemEdited
->GetWidth(),
346 h
= m_itemEdited
->GetHeight();
349 m_owner
->CalcScrolledPosition(item
->GetX(), item
->GetY(), &x
, &y
);
354 int image
= item
->GetCurrentImage();
355 if ( image
!= NO_IMAGE
)
357 if ( m_owner
->m_imageListNormal
)
359 m_owner
->m_imageListNormal
->GetSize( image
, image_w
, image_h
);
364 wxFAIL_MSG(_T("you must create an image list to use images!"));
368 // FIXME: what are all these hardcoded 4, 8 and 11s really?
372 wxSize bs
= DoGetBestSize() ;
373 // edit control height
376 int diff
= h
- ( bs
.y
- 8 ) ;
382 (void)Create(m_owner
, wxID_ANY
, m_startValue
,
383 wxPoint(x
- 4, y
- 4), wxSize(w
+ 11, h
+ 8));
386 bool wxTreeTextCtrl
::AcceptChanges()
388 const wxString value
= GetValue();
390 if ( value
== m_startValue
)
392 // nothing changed, always accept
393 // when an item remains unchanged, the owner
394 // needs to be notified that the user decided
395 // not to change the tree item label, and that
396 // the edit has been cancelled
398 m_owner
->OnRenameCancelled(m_itemEdited
);
402 if ( !m_owner
->OnRenameAccept(m_itemEdited
, value
) )
404 // vetoed by the user
408 // accepted, do rename the item
409 m_owner
->SetItemText(m_itemEdited
, value
);
414 void wxTreeTextCtrl
::Finish()
418 m_owner
->ResetTextControl();
420 wxPendingDelete
.Append(this);
424 m_owner
->SetFocusIgnoringChildren();
428 void wxTreeTextCtrl
::OnChar( wxKeyEvent
&event
)
430 switch ( event
.m_keyCode
)
433 // Notify the owner about the changes
436 // Even if vetoed, close the control (consistent with MSW)
450 void wxTreeTextCtrl
::OnKeyUp( wxKeyEvent
&event
)
454 // auto-grow the textctrl:
455 wxSize parentSize
= m_owner
->GetSize();
456 wxPoint myPos
= GetPosition();
457 wxSize mySize
= GetSize();
459 GetTextExtent(GetValue() + _T("M"), &sx
, &sy
);
460 if (myPos
.x
+ sx
> parentSize
.x
)
461 sx
= parentSize
.x
- myPos
.x
;
464 SetSize(sx
, wxDefaultCoord
);
470 void wxTreeTextCtrl
::OnKillFocus( wxFocusEvent
&event
)
475 // We must finish regardless of success, otherwise we'll get
480 // We must let the native text control handle focus, too, otherwise
481 // it could have problems with the cursor (e.g., in wxGTK):
485 // -----------------------------------------------------------------------------
487 // -----------------------------------------------------------------------------
489 wxGenericTreeItem
::wxGenericTreeItem(wxGenericTreeItem
*parent
,
490 const wxString
& text
,
491 int image
, int selImage
,
492 wxTreeItemData
*data
)
495 m_images
[wxTreeItemIcon_Normal
] = image
;
496 m_images
[wxTreeItemIcon_Selected
] = selImage
;
497 m_images
[wxTreeItemIcon_Expanded
] = NO_IMAGE
;
498 m_images
[wxTreeItemIcon_SelectedExpanded
] = NO_IMAGE
;
503 m_isCollapsed
= true;
504 m_hasHilight
= false;
510 m_attr
= (wxTreeItemAttr
*)NULL
;
513 // We don't know the height here yet.
518 wxGenericTreeItem
::~wxGenericTreeItem()
522 if (m_ownsAttr
) delete m_attr
;
524 wxASSERT_MSG( m_children
.IsEmpty(),
525 wxT("please call DeleteChildren() before deleting the item") );
528 void wxGenericTreeItem
::DeleteChildren(wxGenericTreeCtrl
*tree
)
530 size_t count
= m_children
.Count();
531 for ( size_t n
= 0; n
< count
; n
++ )
533 wxGenericTreeItem
*child
= m_children
[n
];
535 tree
->SendDeleteEvent(child
);
537 child
->DeleteChildren(tree
);
538 if (child
== tree
->m_select_me
)
539 tree
->m_select_me
= NULL
;
546 void wxGenericTreeItem
::SetText( const wxString
&text
)
551 size_t wxGenericTreeItem
::GetChildrenCount(bool recursively
) const
553 size_t count
= m_children
.Count();
557 size_t total
= count
;
558 for (size_t n
= 0; n
< count
; ++n
)
560 total
+= m_children
[n
]->GetChildrenCount();
566 void wxGenericTreeItem
::GetSize( int &x
, int &y
,
567 const wxGenericTreeCtrl
*theButton
)
569 int bottomY
=m_y
+theButton
->GetLineHeight(this);
570 if ( y
< bottomY
) y
= bottomY
;
571 int width
= m_x
+ m_width
;
572 if ( x
< width
) x
= width
;
576 size_t count
= m_children
.Count();
577 for ( size_t n
= 0; n
< count
; ++n
)
579 m_children
[n
]->GetSize( x
, y
, theButton
);
584 wxGenericTreeItem
*wxGenericTreeItem
::HitTest(const wxPoint
& point
,
585 const wxGenericTreeCtrl
*theCtrl
,
589 // for a hidden root node, don't evaluate it, but do evaluate children
590 if ( !(level
== 0 && theCtrl
->HasFlag(wxTR_HIDE_ROOT
)) )
593 int h
= theCtrl
->GetLineHeight(this);
594 if ((point
.y
> m_y
) && (point
.y
< m_y
+ h
))
596 int y_mid
= m_y
+ h
/2;
597 if (point
.y
< y_mid
)
598 flags
|= wxTREE_HITTEST_ONITEMUPPERPART
;
600 flags
|= wxTREE_HITTEST_ONITEMLOWERPART
;
602 int xCross
= m_x
- theCtrl
->GetSpacing();
604 // according to the drawing code the triangels are drawn
605 // at -4 , -4 from the position up to +10/+10 max
606 if ((point
.x
> xCross
-4) && (point
.x
< xCross
+10) &&
607 (point
.y
> y_mid
-4) && (point
.y
< y_mid
+10) &&
608 HasPlus() && theCtrl
->HasButtons() )
610 // 5 is the size of the plus sign
611 if ((point
.x
> xCross
-6) && (point
.x
< xCross
+6) &&
612 (point
.y
> y_mid
-6) && (point
.y
< y_mid
+6) &&
613 HasPlus() && theCtrl
->HasButtons() )
616 flags
|= wxTREE_HITTEST_ONITEMBUTTON
;
620 if ((point
.x
>= m_x
) && (point
.x
<= m_x
+m_width
))
625 // assuming every image (normal and selected) has the same size!
626 if ( (GetImage() != NO_IMAGE
) && theCtrl
->m_imageListNormal
)
627 theCtrl
->m_imageListNormal
->GetSize(GetImage(),
630 if ((image_w
!= -1) && (point
.x
<= m_x
+ image_w
+ 1))
631 flags
|= wxTREE_HITTEST_ONITEMICON
;
633 flags
|= wxTREE_HITTEST_ONITEMLABEL
;
639 flags
|= wxTREE_HITTEST_ONITEMINDENT
;
640 if (point
.x
> m_x
+m_width
)
641 flags
|= wxTREE_HITTEST_ONITEMRIGHT
;
646 // if children are expanded, fall through to evaluate them
647 if (m_isCollapsed
) return (wxGenericTreeItem
*) NULL
;
651 size_t count
= m_children
.Count();
652 for ( size_t n
= 0; n
< count
; n
++ )
654 wxGenericTreeItem
*res
= m_children
[n
]->HitTest( point
,
662 return (wxGenericTreeItem
*) NULL
;
665 int wxGenericTreeItem
::GetCurrentImage() const
667 int image
= NO_IMAGE
;
672 image
= GetImage(wxTreeItemIcon_SelectedExpanded
);
675 if ( image
== NO_IMAGE
)
677 // we usually fall back to the normal item, but try just the
678 // expanded one (and not selected) first in this case
679 image
= GetImage(wxTreeItemIcon_Expanded
);
685 image
= GetImage(wxTreeItemIcon_Selected
);
688 // maybe it doesn't have the specific image we want,
689 // try the default one instead
690 if ( image
== NO_IMAGE
) image
= GetImage();
695 // -----------------------------------------------------------------------------
696 // wxGenericTreeCtrl implementation
697 // -----------------------------------------------------------------------------
699 IMPLEMENT_DYNAMIC_CLASS(wxGenericTreeCtrl
, wxScrolledWindow
)
701 BEGIN_EVENT_TABLE(wxGenericTreeCtrl
,wxScrolledWindow
)
702 EVT_PAINT (wxGenericTreeCtrl
::OnPaint
)
703 EVT_MOUSE_EVENTS (wxGenericTreeCtrl
::OnMouse
)
704 EVT_CHAR (wxGenericTreeCtrl
::OnChar
)
705 EVT_SET_FOCUS (wxGenericTreeCtrl
::OnSetFocus
)
706 EVT_KILL_FOCUS (wxGenericTreeCtrl
::OnKillFocus
)
707 EVT_TREE_ITEM_GETTOOLTIP(wxID_ANY
, wxGenericTreeCtrl
::OnGetToolTip
)
710 #if !defined(__WXMSW__) || defined(__WXUNIVERSAL__)
712 * wxTreeCtrl has to be a real class or we have problems with
713 * the run-time information.
716 IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl
, wxGenericTreeCtrl
)
719 // -----------------------------------------------------------------------------
720 // construction/destruction
721 // -----------------------------------------------------------------------------
723 void wxGenericTreeCtrl
::Init()
725 m_current
= m_key_current
= m_anchor
= m_select_me
= (wxGenericTreeItem
*) NULL
;
733 m_hilightBrush
= new wxBrush
735 wxSystemSettings
::GetColour
737 wxSYS_COLOUR_HIGHLIGHT
742 m_hilightUnfocusedBrush
= new wxBrush
744 wxSystemSettings
::GetColour
746 wxSYS_COLOUR_BTNSHADOW
751 m_imageListNormal
= m_imageListButtons
=
752 m_imageListState
= (wxImageList
*) NULL
;
753 m_ownsImageListNormal
= m_ownsImageListButtons
=
754 m_ownsImageListState
= false;
757 m_isDragging
= false;
758 m_dropTarget
= m_oldSelection
= NULL
;
762 m_renameTimer
= NULL
;
767 m_dropEffectAboveItem
= false;
769 m_lastOnSame
= false;
771 #ifdef __WXMAC_CARBON__
772 m_normalFont
.MacCreateThemeFont( kThemeViewsFont
) ;
774 m_normalFont
= wxSystemSettings
::GetFont( wxSYS_DEFAULT_GUI_FONT
);
776 m_boldFont
= wxFont(m_normalFont
.GetPointSize(),
777 m_normalFont
.GetFamily(),
778 m_normalFont
.GetStyle(),
780 m_normalFont
.GetUnderlined(),
781 m_normalFont
.GetFaceName(),
782 m_normalFont
.GetEncoding());
785 bool wxGenericTreeCtrl
::Create(wxWindow
*parent
,
790 const wxValidator
& wxVALIDATOR_PARAM(validator
),
791 const wxString
& name
)
795 wxGetOsVersion( &major
, &minor
);
797 style
&= ~wxTR_LINES_AT_ROOT
;
798 style
|= wxTR_NO_LINES
;
800 style
|= wxTR_ROW_LINES
;
803 wxScrolledWindow
::Create( parent
, id
, pos
, size
,
804 style
|wxHSCROLL
|wxVSCROLL
, name
);
806 // If the tree display has no buttons, but does have
807 // connecting lines, we can use a narrower layout.
808 // It may not be a good idea to force this...
809 if (!HasButtons() && !HasFlag(wxTR_NO_LINES
))
816 SetValidator( validator
);
819 wxVisualAttributes attr
= GetDefaultAttributes();
820 SetOwnForegroundColour( attr
.colFg
);
821 SetOwnBackgroundColour( attr
.colBg
);
823 SetOwnFont(attr
.font
);
825 // m_dottedPen = wxPen( "grey", 0, wxDOT ); too slow under XFree86
826 m_dottedPen
= wxPen( wxT("grey"), 0, 0 );
833 wxGenericTreeCtrl
::~wxGenericTreeCtrl()
835 delete m_hilightBrush
;
836 delete m_hilightUnfocusedBrush
;
840 delete m_renameTimer
;
843 if (m_ownsImageListNormal
)
844 delete m_imageListNormal
;
845 if (m_ownsImageListState
)
846 delete m_imageListState
;
847 if (m_ownsImageListButtons
)
848 delete m_imageListButtons
;
851 // -----------------------------------------------------------------------------
853 // -----------------------------------------------------------------------------
855 size_t wxGenericTreeCtrl
::GetCount() const
863 size_t count
= m_anchor
->GetChildrenCount();
864 if ( !HasFlag(wxTR_HIDE_ROOT
) )
866 // take the root itself into account
873 void wxGenericTreeCtrl
::SetIndent(unsigned int indent
)
875 m_indent
= (unsigned short) indent
;
879 void wxGenericTreeCtrl
::SetSpacing(unsigned int spacing
)
881 m_spacing
= (unsigned short) spacing
;
886 wxGenericTreeCtrl
::GetChildrenCount(const wxTreeItemId
& item
,
887 bool recursively
) const
889 wxCHECK_MSG( item
.IsOk(), 0u, wxT("invalid tree item") );
891 return ((wxGenericTreeItem
*) item
.m_pItem
)->GetChildrenCount(recursively
);
894 void wxGenericTreeCtrl
::SetWindowStyle(const long styles
)
896 if (!HasFlag(wxTR_HIDE_ROOT
) && (styles
& wxTR_HIDE_ROOT
))
898 // if we will hide the root, make sure children are visible
899 m_anchor
->SetHasPlus();
901 CalculatePositions();
904 // right now, just sets the styles. Eventually, we may
905 // want to update the inherited styles, but right now
906 // none of the parents has updatable styles
907 m_windowStyle
= styles
;
911 // -----------------------------------------------------------------------------
912 // functions to work with tree items
913 // -----------------------------------------------------------------------------
915 wxString wxGenericTreeCtrl
::GetItemText(const wxTreeItemId
& item
) const
917 wxCHECK_MSG( item
.IsOk(), wxT(""), wxT("invalid tree item") );
919 return ((wxGenericTreeItem
*) item
.m_pItem
)->GetText();
922 int wxGenericTreeCtrl
::GetItemImage(const wxTreeItemId
& item
,
923 wxTreeItemIcon which
) const
925 wxCHECK_MSG( item
.IsOk(), -1, wxT("invalid tree item") );
927 return ((wxGenericTreeItem
*) item
.m_pItem
)->GetImage(which
);
930 wxTreeItemData
*wxGenericTreeCtrl
::GetItemData(const wxTreeItemId
& item
) const
932 wxCHECK_MSG( item
.IsOk(), NULL
, wxT("invalid tree item") );
934 return ((wxGenericTreeItem
*) item
.m_pItem
)->GetData();
937 wxColour wxGenericTreeCtrl
::GetItemTextColour(const wxTreeItemId
& item
) const
939 wxCHECK_MSG( item
.IsOk(), wxNullColour
, wxT("invalid tree item") );
941 wxGenericTreeItem
*pItem
= (wxGenericTreeItem
*) item
.m_pItem
;
942 return pItem
->Attr().GetTextColour();
945 wxColour wxGenericTreeCtrl
::GetItemBackgroundColour(const wxTreeItemId
& item
) const
947 wxCHECK_MSG( item
.IsOk(), wxNullColour
, wxT("invalid tree item") );
949 wxGenericTreeItem
*pItem
= (wxGenericTreeItem
*) item
.m_pItem
;
950 return pItem
->Attr().GetBackgroundColour();
953 wxFont wxGenericTreeCtrl
::GetItemFont(const wxTreeItemId
& item
) const
955 wxCHECK_MSG( item
.IsOk(), wxNullFont
, wxT("invalid tree item") );
957 wxGenericTreeItem
*pItem
= (wxGenericTreeItem
*) item
.m_pItem
;
958 return pItem
->Attr().GetFont();
961 void wxGenericTreeCtrl
::SetItemText(const wxTreeItemId
& item
, const wxString
& text
)
963 wxCHECK_RET( item
.IsOk(), wxT("invalid tree item") );
966 wxGenericTreeItem
*pItem
= (wxGenericTreeItem
*) item
.m_pItem
;
967 pItem
->SetText(text
);
968 CalculateSize(pItem
, dc
);
972 void wxGenericTreeCtrl
::SetItemImage(const wxTreeItemId
& item
,
974 wxTreeItemIcon which
)
976 wxCHECK_RET( item
.IsOk(), wxT("invalid tree item") );
978 wxGenericTreeItem
*pItem
= (wxGenericTreeItem
*) item
.m_pItem
;
979 pItem
->SetImage(image
, which
);
982 CalculateSize(pItem
, dc
);
986 void wxGenericTreeCtrl
::SetItemData(const wxTreeItemId
& item
, wxTreeItemData
*data
)
988 wxCHECK_RET( item
.IsOk(), wxT("invalid tree item") );
993 ((wxGenericTreeItem
*) item
.m_pItem
)->SetData(data
);
996 void wxGenericTreeCtrl
::SetItemHasChildren(const wxTreeItemId
& item
, bool has
)
998 wxCHECK_RET( item
.IsOk(), wxT("invalid tree item") );
1000 wxGenericTreeItem
*pItem
= (wxGenericTreeItem
*) item
.m_pItem
;
1001 pItem
->SetHasPlus(has
);
1005 void wxGenericTreeCtrl
::SetItemBold(const wxTreeItemId
& item
, bool bold
)
1007 wxCHECK_RET( item
.IsOk(), wxT("invalid tree item") );
1009 // avoid redrawing the tree if no real change
1010 wxGenericTreeItem
*pItem
= (wxGenericTreeItem
*) item
.m_pItem
;
1011 if ( pItem
->IsBold() != bold
)
1013 pItem
->SetBold(bold
);
1018 void wxGenericTreeCtrl
::SetItemTextColour(const wxTreeItemId
& item
,
1019 const wxColour
& col
)
1021 wxCHECK_RET( item
.IsOk(), wxT("invalid tree item") );
1023 wxGenericTreeItem
*pItem
= (wxGenericTreeItem
*) item
.m_pItem
;
1024 pItem
->Attr().SetTextColour(col
);
1028 void wxGenericTreeCtrl
::SetItemBackgroundColour(const wxTreeItemId
& item
,
1029 const wxColour
& col
)
1031 wxCHECK_RET( item
.IsOk(), wxT("invalid tree item") );
1033 wxGenericTreeItem
*pItem
= (wxGenericTreeItem
*) item
.m_pItem
;
1034 pItem
->Attr().SetBackgroundColour(col
);
1038 void wxGenericTreeCtrl
::SetItemFont(const wxTreeItemId
& item
, const wxFont
& font
)
1040 wxCHECK_RET( item
.IsOk(), wxT("invalid tree item") );
1042 wxGenericTreeItem
*pItem
= (wxGenericTreeItem
*) item
.m_pItem
;
1043 pItem
->Attr().SetFont(font
);
1047 bool wxGenericTreeCtrl
::SetFont( const wxFont
&font
)
1049 wxScrolledWindow
::SetFont(font
);
1051 m_normalFont
= font
;
1052 m_boldFont
= wxFont(m_normalFont
.GetPointSize(),
1053 m_normalFont
.GetFamily(),
1054 m_normalFont
.GetStyle(),
1056 m_normalFont
.GetUnderlined(),
1057 m_normalFont
.GetFaceName(),
1058 m_normalFont
.GetEncoding());
1064 // -----------------------------------------------------------------------------
1065 // item status inquiries
1066 // -----------------------------------------------------------------------------
1068 bool wxGenericTreeCtrl
::IsVisible(const wxTreeItemId
& item
) const
1070 wxCHECK_MSG( item
.IsOk(), false, wxT("invalid tree item") );
1072 // An item is only visible if it's not a descendant of a collapsed item
1073 wxGenericTreeItem
*pItem
= (wxGenericTreeItem
*) item
.m_pItem
;
1074 wxGenericTreeItem
* parent
= pItem
->GetParent();
1077 if (!parent
->IsExpanded())
1079 parent
= parent
->GetParent();
1083 GetViewStart(& startX
, & startY
);
1085 wxSize clientSize
= GetClientSize();
1088 if (!GetBoundingRect(item
, rect
))
1090 if (rect
.GetWidth() == 0 || rect
.GetHeight() == 0)
1092 if (rect
.GetBottom() < 0 || rect
.GetTop() > clientSize
.y
)
1094 if (rect
.GetRight() < 0 || rect
.GetLeft() > clientSize
.x
)
1100 bool wxGenericTreeCtrl
::ItemHasChildren(const wxTreeItemId
& item
) const
1102 wxCHECK_MSG( item
.IsOk(), false, wxT("invalid tree item") );
1104 // consider that the item does have children if it has the "+" button: it
1105 // might not have them (if it had never been expanded yet) but then it
1106 // could have them as well and it's better to err on this side rather than
1107 // disabling some operations which are restricted to the items with
1108 // children for an item which does have them
1109 return ((wxGenericTreeItem
*) item
.m_pItem
)->HasPlus();
1112 bool wxGenericTreeCtrl
::IsExpanded(const wxTreeItemId
& item
) const
1114 wxCHECK_MSG( item
.IsOk(), false, wxT("invalid tree item") );
1116 return ((wxGenericTreeItem
*) item
.m_pItem
)->IsExpanded();
1119 bool wxGenericTreeCtrl
::IsSelected(const wxTreeItemId
& item
) const
1121 wxCHECK_MSG( item
.IsOk(), false, wxT("invalid tree item") );
1123 return ((wxGenericTreeItem
*) item
.m_pItem
)->IsSelected();
1126 bool wxGenericTreeCtrl
::IsBold(const wxTreeItemId
& item
) const
1128 wxCHECK_MSG( item
.IsOk(), false, wxT("invalid tree item") );
1130 return ((wxGenericTreeItem
*) item
.m_pItem
)->IsBold();
1133 // -----------------------------------------------------------------------------
1135 // -----------------------------------------------------------------------------
1137 wxTreeItemId wxGenericTreeCtrl
::GetItemParent(const wxTreeItemId
& item
) const
1139 wxCHECK_MSG( item
.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1141 return ((wxGenericTreeItem
*) item
.m_pItem
)->GetParent();
1144 wxTreeItemId wxGenericTreeCtrl
::GetFirstChild(const wxTreeItemId
& item
,
1145 wxTreeItemIdValue
& cookie
) const
1147 wxCHECK_MSG( item
.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1150 return GetNextChild(item
, cookie
);
1153 wxTreeItemId wxGenericTreeCtrl
::GetNextChild(const wxTreeItemId
& item
,
1154 wxTreeItemIdValue
& cookie
) const
1156 wxCHECK_MSG( item
.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1158 wxArrayGenericTreeItems
& children
= ((wxGenericTreeItem
*) item
.m_pItem
)->GetChildren();
1160 // it's ok to cast cookie to size_t, we never have indices big enough to
1161 // overflow "void *"
1162 size_t *pIndex
= (size_t *)&cookie
;
1163 if ( *pIndex
< children
.Count() )
1165 return children
.Item((*pIndex
)++);
1169 // there are no more of them
1170 return wxTreeItemId();
1174 #if WXWIN_COMPATIBILITY_2_4
1176 wxTreeItemId wxGenericTreeCtrl
::GetFirstChild(const wxTreeItemId
& item
,
1179 wxCHECK_MSG( item
.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1182 return GetNextChild(item
, cookie
);
1185 wxTreeItemId wxGenericTreeCtrl
::GetNextChild(const wxTreeItemId
& item
,
1188 wxCHECK_MSG( item
.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1190 wxArrayGenericTreeItems
& children
= ((wxGenericTreeItem
*) item
.m_pItem
)->GetChildren();
1191 if ( (size_t)cookie
< children
.Count() )
1193 return children
.Item((size_t)cookie
++);
1197 // there are no more of them
1198 return wxTreeItemId();
1202 #endif // WXWIN_COMPATIBILITY_2_4
1204 wxTreeItemId wxGenericTreeCtrl
::GetLastChild(const wxTreeItemId
& item
) const
1206 wxCHECK_MSG( item
.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1208 wxArrayGenericTreeItems
& children
= ((wxGenericTreeItem
*) item
.m_pItem
)->GetChildren();
1209 return (children
.IsEmpty() ?
wxTreeItemId() : wxTreeItemId(children
.Last()));
1212 wxTreeItemId wxGenericTreeCtrl
::GetNextSibling(const wxTreeItemId
& item
) const
1214 wxCHECK_MSG( item
.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1216 wxGenericTreeItem
*i
= (wxGenericTreeItem
*) item
.m_pItem
;
1217 wxGenericTreeItem
*parent
= i
->GetParent();
1218 if ( parent
== NULL
)
1220 // root item doesn't have any siblings
1221 return wxTreeItemId();
1224 wxArrayGenericTreeItems
& siblings
= parent
->GetChildren();
1225 int index
= siblings
.Index(i
);
1226 wxASSERT( index
!= wxNOT_FOUND
); // I'm not a child of my parent?
1228 size_t n
= (size_t)(index
+ 1);
1229 return n
== siblings
.Count() ?
wxTreeItemId() : wxTreeItemId(siblings
[n
]);
1232 wxTreeItemId wxGenericTreeCtrl
::GetPrevSibling(const wxTreeItemId
& item
) const
1234 wxCHECK_MSG( item
.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1236 wxGenericTreeItem
*i
= (wxGenericTreeItem
*) item
.m_pItem
;
1237 wxGenericTreeItem
*parent
= i
->GetParent();
1238 if ( parent
== NULL
)
1240 // root item doesn't have any siblings
1241 return wxTreeItemId();
1244 wxArrayGenericTreeItems
& siblings
= parent
->GetChildren();
1245 int index
= siblings
.Index(i
);
1246 wxASSERT( index
!= wxNOT_FOUND
); // I'm not a child of my parent?
1248 return index
== 0 ?
wxTreeItemId()
1249 : wxTreeItemId(siblings
[(size_t)(index
- 1)]);
1252 // Only for internal use right now, but should probably be public
1253 wxTreeItemId wxGenericTreeCtrl
::GetNext(const wxTreeItemId
& item
) const
1255 wxCHECK_MSG( item
.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1257 wxGenericTreeItem
*i
= (wxGenericTreeItem
*) item
.m_pItem
;
1259 // First see if there are any children.
1260 wxArrayGenericTreeItems
& children
= i
->GetChildren();
1261 if (children
.GetCount() > 0)
1263 return children
.Item(0);
1267 // Try a sibling of this or ancestor instead
1268 wxTreeItemId p
= item
;
1269 wxTreeItemId toFind
;
1272 toFind
= GetNextSibling(p
);
1273 p
= GetItemParent(p
);
1274 } while (p
.IsOk() && !toFind
.IsOk());
1279 wxTreeItemId wxGenericTreeCtrl
::GetFirstVisibleItem() const
1281 wxTreeItemId id
= GetRootItem();
1290 } while (id
.IsOk());
1292 return wxTreeItemId();
1295 wxTreeItemId wxGenericTreeCtrl
::GetNextVisible(const wxTreeItemId
& item
) const
1297 wxCHECK_MSG( item
.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1299 wxTreeItemId id
= item
;
1302 while (id
= GetNext(id
), id
.IsOk())
1308 return wxTreeItemId();
1311 wxTreeItemId wxGenericTreeCtrl
::GetPrevVisible(const wxTreeItemId
& item
) const
1313 wxCHECK_MSG( item
.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1315 wxFAIL_MSG(wxT("not implemented"));
1317 return wxTreeItemId();
1320 // called by wxTextTreeCtrl when it marks itself for deletion
1321 void wxGenericTreeCtrl
::ResetTextControl()
1326 // find the first item starting with the given prefix after the given item
1327 wxTreeItemId wxGenericTreeCtrl
::FindItem(const wxTreeItemId
& idParent
,
1328 const wxString
& prefixOrig
) const
1330 // match is case insensitive as this is more convenient to the user: having
1331 // to press Shift-letter to go to the item starting with a capital letter
1332 // would be too bothersome
1333 wxString prefix
= prefixOrig
.Lower();
1335 // determine the starting point: we shouldn't take the current item (this
1336 // allows to switch between two items starting with the same letter just by
1337 // pressing it) but we shouldn't jump to the next one if the user is
1338 // continuing to type as otherwise he might easily skip the item he wanted
1339 wxTreeItemId id
= idParent
;
1340 if ( prefix
.length() == 1 )
1345 // look for the item starting with the given prefix after it
1346 while ( id
.IsOk() && !GetItemText(id
).Lower().StartsWith(prefix
) )
1351 // if we haven't found anything...
1354 // ... wrap to the beginning
1356 if ( HasFlag(wxTR_HIDE_ROOT
) )
1358 // can't select virtual root
1362 // and try all the items (stop when we get to the one we started from)
1363 while ( id
!= idParent
&& !GetItemText(id
).Lower().StartsWith(prefix
) )
1372 // -----------------------------------------------------------------------------
1374 // -----------------------------------------------------------------------------
1376 wxTreeItemId wxGenericTreeCtrl
::DoInsertItem(const wxTreeItemId
& parentId
,
1378 const wxString
& text
,
1379 int image
, int selImage
,
1380 wxTreeItemData
*data
)
1382 wxGenericTreeItem
*parent
= (wxGenericTreeItem
*) parentId
.m_pItem
;
1385 // should we give a warning here?
1386 return AddRoot(text
, image
, selImage
, data
);
1389 m_dirty
= true; // do this first so stuff below doesn't cause flicker
1391 wxGenericTreeItem
*item
=
1392 new wxGenericTreeItem( parent
, text
, image
, selImage
, data
);
1396 data
->m_pItem
= item
;
1399 parent
->Insert( item
, previous
);
1404 wxTreeItemId wxGenericTreeCtrl
::AddRoot(const wxString
& text
,
1405 int image
, int selImage
,
1406 wxTreeItemData
*data
)
1408 wxCHECK_MSG( !m_anchor
, wxTreeItemId(), wxT("tree can have only one root") );
1410 m_dirty
= true; // do this first so stuff below doesn't cause flicker
1412 m_anchor
= new wxGenericTreeItem((wxGenericTreeItem
*)NULL
, text
,
1413 image
, selImage
, data
);
1416 data
->m_pItem
= m_anchor
;
1419 if (HasFlag(wxTR_HIDE_ROOT
))
1421 // if root is hidden, make sure we can navigate
1423 m_anchor
->SetHasPlus();
1425 CalculatePositions();
1428 if (!HasFlag(wxTR_MULTIPLE
))
1430 m_current
= m_key_current
= m_anchor
;
1431 m_current
->SetHilight( true );
1437 wxTreeItemId wxGenericTreeCtrl
::PrependItem(const wxTreeItemId
& parent
,
1438 const wxString
& text
,
1439 int image
, int selImage
,
1440 wxTreeItemData
*data
)
1442 return DoInsertItem(parent
, 0u, text
, image
, selImage
, data
);
1445 wxTreeItemId wxGenericTreeCtrl
::InsertItem(const wxTreeItemId
& parentId
,
1446 const wxTreeItemId
& idPrevious
,
1447 const wxString
& text
,
1448 int image
, int selImage
,
1449 wxTreeItemData
*data
)
1451 wxGenericTreeItem
*parent
= (wxGenericTreeItem
*) parentId
.m_pItem
;
1454 // should we give a warning here?
1455 return AddRoot(text
, image
, selImage
, data
);
1459 if (idPrevious
.IsOk())
1461 index
= parent
->GetChildren().Index((wxGenericTreeItem
*) idPrevious
.m_pItem
);
1462 wxASSERT_MSG( index
!= wxNOT_FOUND
,
1463 wxT("previous item in wxGenericTreeCtrl::InsertItem() is not a sibling") );
1466 return DoInsertItem(parentId
, (size_t)++index
, text
, image
, selImage
, data
);
1469 wxTreeItemId wxGenericTreeCtrl
::InsertItem(const wxTreeItemId
& parentId
,
1471 const wxString
& text
,
1472 int image
, int selImage
,
1473 wxTreeItemData
*data
)
1475 wxGenericTreeItem
*parent
= (wxGenericTreeItem
*) parentId
.m_pItem
;
1478 // should we give a warning here?
1479 return AddRoot(text
, image
, selImage
, data
);
1482 return DoInsertItem(parentId
, before
, text
, image
, selImage
, data
);
1485 wxTreeItemId wxGenericTreeCtrl
::AppendItem(const wxTreeItemId
& parentId
,
1486 const wxString
& text
,
1487 int image
, int selImage
,
1488 wxTreeItemData
*data
)
1490 wxGenericTreeItem
*parent
= (wxGenericTreeItem
*) parentId
.m_pItem
;
1493 // should we give a warning here?
1494 return AddRoot(text
, image
, selImage
, data
);
1497 return DoInsertItem( parent
, parent
->GetChildren().Count(), text
,
1498 image
, selImage
, data
);
1501 void wxGenericTreeCtrl
::SendDeleteEvent(wxGenericTreeItem
*item
)
1503 wxTreeEvent
event( wxEVT_COMMAND_TREE_DELETE_ITEM
, GetId() );
1504 event
.m_item
= item
;
1505 event
.SetEventObject( this );
1506 ProcessEvent( event
);
1509 // Don't leave edit or selection on a child which is about to disappear
1510 void wxGenericTreeCtrl
::ChildrenClosing(wxGenericTreeItem
* item
)
1512 if (m_textCtrl
!= NULL
&& item
!= m_textCtrl
->item() && IsDescendantOf(item
, m_textCtrl
->item())) {
1513 m_textCtrl
->StopEditing();
1515 if (item
!= m_key_current
&& IsDescendantOf(item
, m_key_current
)) {
1516 m_key_current
= NULL
;
1518 if (IsDescendantOf(item
, m_select_me
)) {
1521 if (item
!= m_current
&& IsDescendantOf(item
, m_current
)) {
1522 m_current
->SetHilight( false );
1528 void wxGenericTreeCtrl
::DeleteChildren(const wxTreeItemId
& itemId
)
1530 m_dirty
= true; // do this first so stuff below doesn't cause flicker
1532 wxGenericTreeItem
*item
= (wxGenericTreeItem
*) itemId
.m_pItem
;
1533 ChildrenClosing(item
);
1534 item
->DeleteChildren(this);
1537 void wxGenericTreeCtrl
::Delete(const wxTreeItemId
& itemId
)
1539 m_dirty
= true; // do this first so stuff below doesn't cause flicker
1541 wxGenericTreeItem
*item
= (wxGenericTreeItem
*) itemId
.m_pItem
;
1543 if (m_textCtrl
!= NULL
&& IsDescendantOf(item
, m_textCtrl
->item()))
1545 // can't delete the item being edited, cancel editing it first
1546 m_textCtrl
->StopEditing();
1549 wxGenericTreeItem
*parent
= item
->GetParent();
1551 // don't keep stale pointers around!
1552 if ( IsDescendantOf(item
, m_key_current
) )
1554 // Don't silently change the selection:
1555 // do it properly in idle time, so event
1556 // handlers get called.
1558 // m_key_current = parent;
1559 m_key_current
= NULL
;
1562 // m_select_me records whether we need to select
1563 // a different item, in idle time.
1564 if ( m_select_me
&& IsDescendantOf(item
, m_select_me
) )
1566 m_select_me
= parent
;
1569 if ( IsDescendantOf(item
, m_current
) )
1571 // Don't silently change the selection:
1572 // do it properly in idle time, so event
1573 // handlers get called.
1575 // m_current = parent;
1577 m_select_me
= parent
;
1580 // remove the item from the tree
1583 parent
->GetChildren().Remove( item
); // remove by value
1585 else // deleting the root
1587 // nothing will be left in the tree
1591 // and delete all of its children and the item itself now
1592 item
->DeleteChildren(this);
1593 SendDeleteEvent(item
);
1595 if (item
== m_select_me
)
1601 void wxGenericTreeCtrl
::DeleteAllItems()
1609 void wxGenericTreeCtrl
::Expand(const wxTreeItemId
& itemId
)
1611 wxGenericTreeItem
*item
= (wxGenericTreeItem
*) itemId
.m_pItem
;
1613 wxCHECK_RET( item
, _T("invalid item in wxGenericTreeCtrl::Expand") );
1614 wxCHECK_RET( !HasFlag(wxTR_HIDE_ROOT
) || itemId
!= GetRootItem(),
1615 _T("can't expand hidden root") );
1617 if ( !item
->HasPlus() )
1620 if ( item
->IsExpanded() )
1623 wxTreeEvent
event( wxEVT_COMMAND_TREE_ITEM_EXPANDING
, GetId() );
1624 event
.m_item
= item
;
1625 event
.SetEventObject( this );
1627 if ( ProcessEvent( event
) && !event
.IsAllowed() )
1629 // cancelled by program
1634 CalculatePositions();
1636 RefreshSubtree(item
);
1638 event
.SetEventType(wxEVT_COMMAND_TREE_ITEM_EXPANDED
);
1639 ProcessEvent( event
);
1642 void wxGenericTreeCtrl
::ExpandAll(const wxTreeItemId
& item
)
1644 if ( !HasFlag(wxTR_HIDE_ROOT
) || item
!= GetRootItem())
1647 if ( !IsExpanded(item
) )
1651 wxTreeItemIdValue cookie
;
1652 wxTreeItemId child
= GetFirstChild(item
, cookie
);
1653 while ( child
.IsOk() )
1657 child
= GetNextChild(item
, cookie
);
1661 void wxGenericTreeCtrl
::Collapse(const wxTreeItemId
& itemId
)
1663 wxCHECK_RET( !HasFlag(wxTR_HIDE_ROOT
) || itemId
!= GetRootItem(),
1664 _T("can't collapse hidden root") );
1666 wxGenericTreeItem
*item
= (wxGenericTreeItem
*) itemId
.m_pItem
;
1668 if ( !item
->IsExpanded() )
1671 wxTreeEvent
event( wxEVT_COMMAND_TREE_ITEM_COLLAPSING
, GetId() );
1672 event
.m_item
= item
;
1673 event
.SetEventObject( this );
1674 if ( ProcessEvent( event
) && !event
.IsAllowed() )
1676 // cancelled by program
1680 ChildrenClosing(item
);
1683 #if 0 // TODO why should items be collapsed recursively?
1684 wxArrayGenericTreeItems
& children
= item
->GetChildren();
1685 size_t count
= children
.Count();
1686 for ( size_t n
= 0; n
< count
; n
++ )
1688 Collapse(children
[n
]);
1692 CalculatePositions();
1694 RefreshSubtree(item
);
1696 event
.SetEventType(wxEVT_COMMAND_TREE_ITEM_COLLAPSED
);
1697 ProcessEvent( event
);
1700 void wxGenericTreeCtrl
::CollapseAndReset(const wxTreeItemId
& item
)
1703 DeleteChildren(item
);
1706 void wxGenericTreeCtrl
::Toggle(const wxTreeItemId
& itemId
)
1708 wxGenericTreeItem
*item
= (wxGenericTreeItem
*) itemId
.m_pItem
;
1710 if (item
->IsExpanded())
1716 void wxGenericTreeCtrl
::Unselect()
1720 m_current
->SetHilight( false );
1721 RefreshLine( m_current
);
1728 void wxGenericTreeCtrl
::UnselectAllChildren(wxGenericTreeItem
*item
)
1730 if (item
->IsSelected())
1732 item
->SetHilight(false);
1736 if (item
->HasChildren())
1738 wxArrayGenericTreeItems
& children
= item
->GetChildren();
1739 size_t count
= children
.Count();
1740 for ( size_t n
= 0; n
< count
; ++n
)
1742 UnselectAllChildren(children
[n
]);
1747 void wxGenericTreeCtrl
::UnselectAll()
1749 wxTreeItemId rootItem
= GetRootItem();
1751 // the tree might not have the root item at all
1754 UnselectAllChildren((wxGenericTreeItem
*) rootItem
.m_pItem
);
1758 // Recursive function !
1759 // To stop we must have crt_item<last_item
1761 // Tag all next children, when no more children,
1762 // Move to parent (not to tag)
1763 // Keep going... if we found last_item, we stop.
1764 bool wxGenericTreeCtrl
::TagNextChildren(wxGenericTreeItem
*crt_item
, wxGenericTreeItem
*last_item
, bool select
)
1766 wxGenericTreeItem
*parent
= crt_item
->GetParent();
1768 if (parent
== NULL
) // This is root item
1769 return TagAllChildrenUntilLast(crt_item
, last_item
, select
);
1771 wxArrayGenericTreeItems
& children
= parent
->GetChildren();
1772 int index
= children
.Index(crt_item
);
1773 wxASSERT( index
!= wxNOT_FOUND
); // I'm not a child of my parent?
1775 size_t count
= children
.Count();
1776 for (size_t n
=(size_t)(index
+1); n
<count
; ++n
)
1778 if (TagAllChildrenUntilLast(children
[n
], last_item
, select
)) return true;
1781 return TagNextChildren(parent
, last_item
, select
);
1784 bool wxGenericTreeCtrl
::TagAllChildrenUntilLast(wxGenericTreeItem
*crt_item
, wxGenericTreeItem
*last_item
, bool select
)
1786 crt_item
->SetHilight(select
);
1787 RefreshLine(crt_item
);
1789 if (crt_item
==last_item
)
1792 if (crt_item
->HasChildren())
1794 wxArrayGenericTreeItems
& children
= crt_item
->GetChildren();
1795 size_t count
= children
.Count();
1796 for ( size_t n
= 0; n
< count
; ++n
)
1798 if (TagAllChildrenUntilLast(children
[n
], last_item
, select
))
1806 void wxGenericTreeCtrl
::SelectItemRange(wxGenericTreeItem
*item1
, wxGenericTreeItem
*item2
)
1810 // item2 is not necessary after item1
1811 // choice first' and 'last' between item1 and item2
1812 wxGenericTreeItem
*first
= (item1
->GetY()<item2
->GetY()) ? item1
: item2
;
1813 wxGenericTreeItem
*last
= (item1
->GetY()<item2
->GetY()) ? item2
: item1
;
1815 bool select
= m_current
->IsSelected();
1817 if ( TagAllChildrenUntilLast(first
,last
,select
) )
1820 TagNextChildren(first
,last
,select
);
1823 void wxGenericTreeCtrl
::DoSelectItem(const wxTreeItemId
& itemId
,
1824 bool unselect_others
,
1825 bool extended_select
)
1827 wxCHECK_RET( itemId
.IsOk(), wxT("invalid tree item") );
1831 bool is_single
=!(GetWindowStyleFlag() & wxTR_MULTIPLE
);
1832 wxGenericTreeItem
*item
= (wxGenericTreeItem
*) itemId
.m_pItem
;
1834 //wxCHECK_RET( ( (!unselect_others) && is_single),
1835 // wxT("this is a single selection tree") );
1837 // to keep going anyhow !!!
1840 if (item
->IsSelected())
1841 return; // nothing to do
1842 unselect_others
= true;
1843 extended_select
= false;
1845 else if ( unselect_others
&& item
->IsSelected() )
1847 // selection change if there is more than one item currently selected
1848 wxArrayTreeItemIds selected_items
;
1849 if ( GetSelections(selected_items
) == 1 )
1853 wxTreeEvent
event( wxEVT_COMMAND_TREE_SEL_CHANGING
, GetId() );
1854 event
.m_item
= item
;
1855 event
.m_itemOld
= m_current
;
1856 event
.SetEventObject( this );
1857 // TODO : Here we don't send any selection mode yet !
1859 if ( GetEventHandler()->ProcessEvent( event
) && !event
.IsAllowed() )
1862 wxTreeItemId parent
= GetItemParent( itemId
);
1863 while (parent
.IsOk())
1865 if (!IsExpanded(parent
))
1868 parent
= GetItemParent( parent
);
1871 EnsureVisible( itemId
);
1874 if (unselect_others
)
1876 if (is_single
) Unselect(); // to speed up thing
1881 if (extended_select
)
1885 m_current
= m_key_current
= (wxGenericTreeItem
*) GetRootItem().m_pItem
;
1888 // don't change the mark (m_current)
1889 SelectItemRange(m_current
, item
);
1893 bool select
= true; // the default
1895 // Check if we need to toggle hilight (ctrl mode)
1896 if (!unselect_others
)
1897 select
=!item
->IsSelected();
1899 m_current
= m_key_current
= item
;
1900 m_current
->SetHilight(select
);
1901 RefreshLine( m_current
);
1904 event
.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED
);
1905 GetEventHandler()->ProcessEvent( event
);
1908 void wxGenericTreeCtrl
::SelectItem(const wxTreeItemId
& itemId
, bool select
)
1912 DoSelectItem(itemId
);
1916 wxGenericTreeItem
*item
= (wxGenericTreeItem
*) itemId
.m_pItem
;
1917 wxCHECK_RET( item
, wxT("SelectItem(): invalid tree item") );
1919 item
->SetHilight(false);
1924 void wxGenericTreeCtrl
::FillArray(wxGenericTreeItem
*item
,
1925 wxArrayTreeItemIds
&array
) const
1927 if ( item
->IsSelected() )
1928 array
.Add(wxTreeItemId(item
));
1930 if ( item
->HasChildren() )
1932 wxArrayGenericTreeItems
& children
= item
->GetChildren();
1933 size_t count
= children
.GetCount();
1934 for ( size_t n
= 0; n
< count
; ++n
)
1935 FillArray(children
[n
], array
);
1939 size_t wxGenericTreeCtrl
::GetSelections(wxArrayTreeItemIds
&array
) const
1942 wxTreeItemId idRoot
= GetRootItem();
1943 if ( idRoot
.IsOk() )
1945 FillArray((wxGenericTreeItem
*) idRoot
.m_pItem
, array
);
1947 //else: the tree is empty, so no selections
1949 return array
.Count();
1952 void wxGenericTreeCtrl
::EnsureVisible(const wxTreeItemId
& item
)
1954 wxCHECK_RET( item
.IsOk(), wxT("invalid tree item") );
1956 if (!item
.IsOk()) return;
1958 wxGenericTreeItem
*gitem
= (wxGenericTreeItem
*) item
.m_pItem
;
1960 // first expand all parent branches
1961 wxGenericTreeItem
*parent
= gitem
->GetParent();
1963 if ( HasFlag(wxTR_HIDE_ROOT
) )
1965 while ( parent
&& parent
!= m_anchor
)
1968 parent
= parent
->GetParent();
1976 parent
= parent
->GetParent();
1980 //if (parent) CalculatePositions();
1985 void wxGenericTreeCtrl
::ScrollTo(const wxTreeItemId
&item
)
1987 if (!item
.IsOk()) return;
1989 // We have to call this here because the label in
1990 // question might just have been added and no screen
1991 // update taken place.
1993 #if defined( __WXMSW__ ) || defined(__WXMAC__)
1998 wxGenericTreeItem
*gitem
= (wxGenericTreeItem
*) item
.m_pItem
;
2000 // now scroll to the item
2001 int item_y
= gitem
->GetY();
2005 GetViewStart( &start_x
, &start_y
);
2006 start_y
*= PIXELS_PER_UNIT
;
2010 GetClientSize( &client_w
, &client_h
);
2012 if (item_y
< start_y
+3)
2017 m_anchor
->GetSize( x
, y
, this );
2018 y
+= PIXELS_PER_UNIT
+2; // one more scrollbar unit + 2 pixels
2019 x
+= PIXELS_PER_UNIT
+2; // one more scrollbar unit + 2 pixels
2020 int x_pos
= GetScrollPos( wxHORIZONTAL
);
2021 // Item should appear at top
2022 SetScrollbars( PIXELS_PER_UNIT
, PIXELS_PER_UNIT
, x
/PIXELS_PER_UNIT
, y
/PIXELS_PER_UNIT
, x_pos
, item_y
/PIXELS_PER_UNIT
);
2024 else if (item_y
+GetLineHeight(gitem
) > start_y
+client_h
)
2029 m_anchor
->GetSize( x
, y
, this );
2030 y
+= PIXELS_PER_UNIT
+2; // one more scrollbar unit + 2 pixels
2031 x
+= PIXELS_PER_UNIT
+2; // one more scrollbar unit + 2 pixels
2032 item_y
+= PIXELS_PER_UNIT
+2;
2033 int x_pos
= GetScrollPos( wxHORIZONTAL
);
2034 // Item should appear at bottom
2035 SetScrollbars( PIXELS_PER_UNIT
, PIXELS_PER_UNIT
, x
/PIXELS_PER_UNIT
, y
/PIXELS_PER_UNIT
, x_pos
, (item_y
+GetLineHeight(gitem
)-client_h
)/PIXELS_PER_UNIT
);
2039 // FIXME: tree sorting functions are not reentrant and not MT-safe!
2040 static wxGenericTreeCtrl
*s_treeBeingSorted
= NULL
;
2042 static int LINKAGEMODE
tree_ctrl_compare_func(wxGenericTreeItem
**item1
,
2043 wxGenericTreeItem
**item2
)
2045 wxCHECK_MSG( s_treeBeingSorted
, 0, wxT("bug in wxGenericTreeCtrl::SortChildren()") );
2047 return s_treeBeingSorted
->OnCompareItems(*item1
, *item2
);
2050 int wxGenericTreeCtrl
::OnCompareItems(const wxTreeItemId
& item1
,
2051 const wxTreeItemId
& item2
)
2053 return wxStrcmp(GetItemText(item1
), GetItemText(item2
));
2056 void wxGenericTreeCtrl
::SortChildren(const wxTreeItemId
& itemId
)
2058 wxCHECK_RET( itemId
.IsOk(), wxT("invalid tree item") );
2060 wxGenericTreeItem
*item
= (wxGenericTreeItem
*) itemId
.m_pItem
;
2062 wxCHECK_RET( !s_treeBeingSorted
,
2063 wxT("wxGenericTreeCtrl::SortChildren is not reentrant") );
2065 wxArrayGenericTreeItems
& children
= item
->GetChildren();
2066 if ( children
.Count() > 1 )
2070 s_treeBeingSorted
= this;
2071 children
.Sort(tree_ctrl_compare_func
);
2072 s_treeBeingSorted
= NULL
;
2074 //else: don't make the tree dirty as nothing changed
2077 wxImageList
*wxGenericTreeCtrl
::GetImageList() const
2079 return m_imageListNormal
;
2082 wxImageList
*wxGenericTreeCtrl
::GetButtonsImageList() const
2084 return m_imageListButtons
;
2087 wxImageList
*wxGenericTreeCtrl
::GetStateImageList() const
2089 return m_imageListState
;
2092 void wxGenericTreeCtrl
::CalculateLineHeight()
2094 wxClientDC
dc(this);
2095 m_lineHeight
= (int)(dc
.GetCharHeight() + 4);
2097 if ( m_imageListNormal
)
2099 // Calculate a m_lineHeight value from the normal Image sizes.
2100 // May be toggle off. Then wxGenericTreeCtrl will spread when
2101 // necessary (which might look ugly).
2102 int n
= m_imageListNormal
->GetImageCount();
2103 for (int i
= 0; i
< n
; i
++)
2105 int width
= 0, height
= 0;
2106 m_imageListNormal
->GetSize(i
, width
, height
);
2107 if (height
> m_lineHeight
) m_lineHeight
= height
;
2111 if (m_imageListButtons
)
2113 // Calculate a m_lineHeight value from the Button image sizes.
2114 // May be toggle off. Then wxGenericTreeCtrl will spread when
2115 // necessary (which might look ugly).
2116 int n
= m_imageListButtons
->GetImageCount();
2117 for (int i
= 0; i
< n
; i
++)
2119 int width
= 0, height
= 0;
2120 m_imageListButtons
->GetSize(i
, width
, height
);
2121 if (height
> m_lineHeight
) m_lineHeight
= height
;
2125 if (m_lineHeight
< 30)
2126 m_lineHeight
+= 2; // at least 2 pixels
2128 m_lineHeight
+= m_lineHeight
/10; // otherwise 10% extra spacing
2131 void wxGenericTreeCtrl
::SetImageList(wxImageList
*imageList
)
2133 if (m_ownsImageListNormal
) delete m_imageListNormal
;
2134 m_imageListNormal
= imageList
;
2135 m_ownsImageListNormal
= false;
2137 // Don't do any drawing if we're setting the list to NULL,
2138 // since we may be in the process of deleting the tree control.
2140 CalculateLineHeight();
2143 void wxGenericTreeCtrl
::SetStateImageList(wxImageList
*imageList
)
2145 if (m_ownsImageListState
) delete m_imageListState
;
2146 m_imageListState
= imageList
;
2147 m_ownsImageListState
= false;
2150 void wxGenericTreeCtrl
::SetButtonsImageList(wxImageList
*imageList
)
2152 if (m_ownsImageListButtons
) delete m_imageListButtons
;
2153 m_imageListButtons
= imageList
;
2154 m_ownsImageListButtons
= false;
2156 CalculateLineHeight();
2159 void wxGenericTreeCtrl
::AssignImageList(wxImageList
*imageList
)
2161 SetImageList(imageList
);
2162 m_ownsImageListNormal
= true;
2165 void wxGenericTreeCtrl
::AssignStateImageList(wxImageList
*imageList
)
2167 SetStateImageList(imageList
);
2168 m_ownsImageListState
= true;
2171 void wxGenericTreeCtrl
::AssignButtonsImageList(wxImageList
*imageList
)
2173 SetButtonsImageList(imageList
);
2174 m_ownsImageListButtons
= true;
2177 // -----------------------------------------------------------------------------
2179 // -----------------------------------------------------------------------------
2181 void wxGenericTreeCtrl
::AdjustMyScrollbars()
2186 m_anchor
->GetSize( x
, y
, this );
2187 y
+= PIXELS_PER_UNIT
+2; // one more scrollbar unit + 2 pixels
2188 x
+= PIXELS_PER_UNIT
+2; // one more scrollbar unit + 2 pixels
2189 int x_pos
= GetScrollPos( wxHORIZONTAL
);
2190 int y_pos
= GetScrollPos( wxVERTICAL
);
2191 SetScrollbars( PIXELS_PER_UNIT
, PIXELS_PER_UNIT
, x
/PIXELS_PER_UNIT
, y
/PIXELS_PER_UNIT
, x_pos
, y_pos
);
2195 SetScrollbars( 0, 0, 0, 0 );
2199 int wxGenericTreeCtrl
::GetLineHeight(wxGenericTreeItem
*item
) const
2201 if (GetWindowStyleFlag() & wxTR_HAS_VARIABLE_ROW_HEIGHT
)
2202 return item
->GetHeight();
2204 return m_lineHeight
;
2207 void wxGenericTreeCtrl
::PaintItem(wxGenericTreeItem
*item
, wxDC
& dc
)
2209 // TODO implement "state" icon on items
2211 wxTreeItemAttr
*attr
= item
->GetAttributes();
2212 if ( attr
&& attr
->HasFont() )
2213 dc
.SetFont(attr
->GetFont());
2214 else if (item
->IsBold())
2215 dc
.SetFont(m_boldFont
);
2217 long text_w
= 0, text_h
= 0;
2218 dc
.GetTextExtent( item
->GetText(), &text_w
, &text_h
);
2220 int image_h
= 0, image_w
= 0;
2221 int image
= item
->GetCurrentImage();
2222 if ( image
!= NO_IMAGE
)
2224 if ( m_imageListNormal
)
2226 m_imageListNormal
->GetSize( image
, image_w
, image_h
);
2235 int total_h
= GetLineHeight(item
);
2237 if ( item
->IsSelected() )
2239 // under mac selections are only a rectangle in case they don't have the focus
2243 dc
.SetBrush( *wxTRANSPARENT_BRUSH
) ;
2244 dc
.SetPen( wxPen( wxSystemSettings
::GetColour( wxSYS_COLOUR_HIGHLIGHT
) , 1 , wxSOLID
) ) ;
2248 dc
.SetBrush( *m_hilightBrush
) ;
2251 dc
.SetBrush(*(m_hasFocus ? m_hilightBrush
: m_hilightUnfocusedBrush
));
2257 if ( attr
&& attr
->HasBackgroundColour() )
2258 colBg
= attr
->GetBackgroundColour();
2260 colBg
= m_backgroundColour
;
2261 dc
.SetBrush(wxBrush(colBg
, wxSOLID
));
2264 int offset
= HasFlag(wxTR_ROW_LINES
) ?
1 : 0;
2266 if ( HasFlag(wxTR_FULL_ROW_HIGHLIGHT
) )
2270 DoGetPosition(&x
, &y
);
2272 dc
.DrawRectangle(x
, item
->GetY()+offset
, w
, total_h
-offset
);
2276 if ( item
->IsSelected() && image
!= NO_IMAGE
)
2278 // If it's selected, and there's an image, then we should
2279 // take care to leave the area under the image painted in the
2280 // background colour.
2281 dc
.DrawRectangle( item
->GetX() + image_w
- 2, item
->GetY()+offset
,
2282 item
->GetWidth() - image_w
+ 2, total_h
-offset
);
2286 dc
.DrawRectangle( item
->GetX()-2, item
->GetY()+offset
,
2287 item
->GetWidth()+2, total_h
-offset
);
2291 if ( image
!= NO_IMAGE
)
2293 dc
.SetClippingRegion( item
->GetX(), item
->GetY(), image_w
-2, total_h
);
2294 m_imageListNormal
->Draw( image
, dc
,
2296 item
->GetY() +((total_h
> image_h
)?
((total_h
-image_h
)/2):0),
2297 wxIMAGELIST_DRAW_TRANSPARENT
);
2298 dc
.DestroyClippingRegion();
2301 dc
.SetBackgroundMode(wxTRANSPARENT
);
2302 int extraH
= (total_h
> text_h
) ?
(total_h
- text_h
)/2 : 0;
2303 dc
.DrawText( item
->GetText(),
2304 (wxCoord
)(image_w
+ item
->GetX()),
2305 (wxCoord
)(item
->GetY() + extraH
));
2307 // restore normal font
2308 dc
.SetFont( m_normalFont
);
2311 // Now y stands for the top of the item, whereas it used to stand for middle !
2312 void wxGenericTreeCtrl
::PaintLevel( wxGenericTreeItem
*item
, wxDC
&dc
, int level
, int &y
)
2314 int x
= level
*m_indent
;
2315 if (!HasFlag(wxTR_HIDE_ROOT
))
2319 else if (level
== 0)
2321 // always expand hidden root
2323 wxArrayGenericTreeItems
& children
= item
->GetChildren();
2324 int count
= children
.Count();
2330 PaintLevel(children
[n
], dc
, 1, y
);
2331 } while (++n
< count
);
2333 if (!HasFlag(wxTR_NO_LINES
) && HasFlag(wxTR_LINES_AT_ROOT
) && count
> 0)
2335 // draw line down to last child
2336 origY
+= GetLineHeight(children
[0])>>1;
2337 oldY
+= GetLineHeight(children
[n
-1])>>1;
2338 dc
.DrawLine(3, origY
, 3, oldY
);
2344 item
->SetX(x
+m_spacing
);
2347 int h
= GetLineHeight(item
);
2349 int y_mid
= y_top
+ (h
>>1);
2352 int exposed_x
= dc
.LogicalToDeviceX(0);
2353 int exposed_y
= dc
.LogicalToDeviceY(y_top
);
2355 if (IsExposed(exposed_x
, exposed_y
, 10000, h
)) // 10000 = very much
2359 // don't draw rect outline if we already have the
2360 // background color under Mac
2361 (item
->IsSelected() && m_hasFocus
) ? wxBLACK_PEN
:
2362 #endif // !__WXMAC__
2366 if ( item
->IsSelected() )
2368 colText
= wxSystemSettings
::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT
);
2372 wxTreeItemAttr
*attr
= item
->GetAttributes();
2373 if (attr
&& attr
->HasTextColour())
2374 colText
= attr
->GetTextColour();
2376 colText
= GetForegroundColour();
2380 dc
.SetTextForeground(colText
);
2384 PaintItem(item
, dc
);
2386 if (HasFlag(wxTR_ROW_LINES
))
2388 // if the background colour is white, choose a
2389 // contrasting color for the lines
2390 dc
.SetPen(*((GetBackgroundColour() == *wxWHITE
)
2391 ? wxMEDIUM_GREY_PEN
: wxWHITE_PEN
));
2392 dc
.DrawLine(0, y_top
, 10000, y_top
);
2393 dc
.DrawLine(0, y
, 10000, y
);
2396 // restore DC objects
2397 dc
.SetBrush(*wxWHITE_BRUSH
);
2398 dc
.SetPen(m_dottedPen
);
2399 dc
.SetTextForeground(*wxBLACK
);
2401 if ( !HasFlag(wxTR_NO_LINES
) )
2403 // draw the horizontal line here
2405 if (x
> (signed)m_indent
)
2406 x_start
-= m_indent
;
2407 else if (HasFlag(wxTR_LINES_AT_ROOT
))
2409 dc
.DrawLine(x_start
, y_mid
, x
+ m_spacing
, y_mid
);
2412 // should the item show a button?
2413 if ( item
->HasPlus() && HasButtons() )
2415 if ( m_imageListButtons
)
2417 // draw the image button here
2420 int image
= item
->IsExpanded() ? wxTreeItemIcon_Expanded
2421 : wxTreeItemIcon_Normal
;
2422 if ( item
->IsSelected() )
2423 image
+= wxTreeItemIcon_Selected
- wxTreeItemIcon_Normal
;
2425 m_imageListButtons
->GetSize(image
, image_w
, image_h
);
2426 int xx
= x
- image_w
/2;
2427 int yy
= y_mid
- image_h
/2;
2429 wxDCClipper
clip(dc
, xx
, yy
, image_w
, image_h
);
2430 m_imageListButtons
->Draw(image
, dc
, xx
, yy
,
2431 wxIMAGELIST_DRAW_TRANSPARENT
);
2433 else // no custom buttons
2435 static const int wImage
= 9;
2436 static const int hImage
= 9;
2439 if (item
->IsExpanded())
2440 flag
|= wxCONTROL_EXPANDED
;
2441 if (item
== m_underMouse
)
2442 flag
|= wxCONTROL_CURRENT
;
2444 wxRendererNative
::Get().DrawTreeItemButton
2448 wxRect(x
- wImage
/2,
2457 if (item
->IsExpanded())
2459 wxArrayGenericTreeItems
& children
= item
->GetChildren();
2460 int count
= children
.Count();
2467 PaintLevel(children
[n
], dc
, level
, y
);
2468 } while (++n
< count
);
2470 if (!HasFlag(wxTR_NO_LINES
) && count
> 0)
2472 // draw line down to last child
2473 oldY
+= GetLineHeight(children
[n
-1])>>1;
2474 if (HasButtons()) y_mid
+= 5;
2476 // Only draw the portion of the line that is visible, in case it is huge
2477 wxCoord xOrigin
=0, yOrigin
=0, width
, height
;
2478 dc
.GetDeviceOrigin(&xOrigin
, &yOrigin
);
2479 yOrigin
= abs(yOrigin
);
2480 GetClientSize(&width
, &height
);
2482 // Move end points to the begining/end of the view?
2483 if (y_mid
< yOrigin
)
2485 if (oldY
> yOrigin
+ height
)
2486 oldY
= yOrigin
+ height
;
2488 // after the adjustments if y_mid is larger than oldY then the line
2489 // isn't visible at all so don't draw anything
2491 dc
.DrawLine(x
, y_mid
, x
, oldY
);
2497 void wxGenericTreeCtrl
::DrawDropEffect(wxGenericTreeItem
*item
)
2501 if ( item
->HasPlus() )
2503 // it's a folder, indicate it by a border
2508 // draw a line under the drop target because the item will be
2510 DrawLine(item
, !m_dropEffectAboveItem
);
2513 SetCursor(wxCURSOR_BULLSEYE
);
2518 SetCursor(wxCURSOR_NO_ENTRY
);
2522 void wxGenericTreeCtrl
::DrawBorder(const wxTreeItemId
&item
)
2524 wxCHECK_RET( item
.IsOk(), _T("invalid item in wxGenericTreeCtrl::DrawLine") );
2526 wxGenericTreeItem
*i
= (wxGenericTreeItem
*) item
.m_pItem
;
2528 wxClientDC
dc(this);
2530 dc
.SetLogicalFunction(wxINVERT
);
2531 dc
.SetBrush(*wxTRANSPARENT_BRUSH
);
2533 int w
= i
->GetWidth() + 2;
2534 int h
= GetLineHeight(i
) + 2;
2536 dc
.DrawRectangle( i
->GetX() - 1, i
->GetY() - 1, w
, h
);
2539 void wxGenericTreeCtrl
::DrawLine(const wxTreeItemId
&item
, bool below
)
2541 wxCHECK_RET( item
.IsOk(), _T("invalid item in wxGenericTreeCtrl::DrawLine") );
2543 wxGenericTreeItem
*i
= (wxGenericTreeItem
*) item
.m_pItem
;
2545 wxClientDC
dc(this);
2547 dc
.SetLogicalFunction(wxINVERT
);
2553 y
+= GetLineHeight(i
) - 1;
2556 dc
.DrawLine( x
, y
, x
+ i
->GetWidth(), y
);
2559 // -----------------------------------------------------------------------------
2560 // wxWidgets callbacks
2561 // -----------------------------------------------------------------------------
2563 void wxGenericTreeCtrl
::OnPaint( wxPaintEvent
&WXUNUSED(event
) )
2571 dc
.SetFont( m_normalFont
);
2572 dc
.SetPen( m_dottedPen
);
2574 // this is now done dynamically
2575 //if(GetImageList() == NULL)
2576 // m_lineHeight = (int)(dc.GetCharHeight() + 4);
2579 PaintLevel( m_anchor
, dc
, 0, y
);
2582 void wxGenericTreeCtrl
::OnSetFocus( wxFocusEvent
&event
)
2591 void wxGenericTreeCtrl
::OnKillFocus( wxFocusEvent
&event
)
2600 void wxGenericTreeCtrl
::OnChar( wxKeyEvent
&event
)
2602 wxTreeEvent
te( wxEVT_COMMAND_TREE_KEY_DOWN
, GetId() );
2603 te
.m_evtKey
= event
;
2604 te
.SetEventObject( this );
2605 if ( GetEventHandler()->ProcessEvent( te
) )
2607 // intercepted by the user code
2611 if ( (m_current
== 0) || (m_key_current
== 0) )
2617 // how should the selection work for this event?
2618 bool is_multiple
, extended_select
, unselect_others
;
2619 EventFlagsToSelType(GetWindowStyleFlag(),
2621 event
.ControlDown(),
2622 is_multiple
, extended_select
, unselect_others
);
2626 // * : Expand all/Collapse all
2627 // ' ' | return : activate
2628 // up : go up (not last children!)
2630 // left : go to parent
2631 // right : open if parent and go next
2632 // home : go to root
2633 // end : go to last item without opening parents
2634 // alnum : start or continue searching for the item with this prefix
2635 int keyCode
= event
.GetKeyCode();
2640 if (m_current
->HasPlus() && !IsExpanded(m_current
))
2648 if ( !IsExpanded(m_current
) )
2651 ExpandAll(m_current
);
2654 //else: fall through to Collapse() it
2658 if (IsExpanded(m_current
))
2660 Collapse(m_current
);
2666 wxTreeEvent
event( wxEVT_COMMAND_TREE_ITEM_MENU
, GetId() );
2667 event
.m_item
= m_current
;
2668 event
.SetEventObject( this );
2669 GetEventHandler()->ProcessEvent( event
);
2674 if ( !event
.HasModifiers() )
2676 wxTreeEvent
event( wxEVT_COMMAND_TREE_ITEM_ACTIVATED
, GetId() );
2677 event
.m_item
= m_current
;
2678 event
.SetEventObject( this );
2679 GetEventHandler()->ProcessEvent( event
);
2682 // in any case, also generate the normal key event for this key,
2683 // even if we generated the ACTIVATED event above: this is what
2684 // wxMSW does and it makes sense because you might not want to
2685 // process ACTIVATED event at all and handle Space and Return
2686 // directly (and differently) which would be impossible otherwise
2690 // up goes to the previous sibling or to the last
2691 // of its children if it's expanded
2694 wxTreeItemId prev
= GetPrevSibling( m_key_current
);
2697 prev
= GetItemParent( m_key_current
);
2698 if ((prev
== GetRootItem()) && HasFlag(wxTR_HIDE_ROOT
))
2700 break; // don't go to root if it is hidden
2704 wxTreeItemIdValue cookie
;
2705 wxTreeItemId current
= m_key_current
;
2706 // TODO: Huh? If we get here, we'd better be the first child of our parent. How else could it be?
2707 if (current
== GetFirstChild( prev
, cookie
))
2709 // otherwise we return to where we came from
2710 DoSelectItem( prev
, unselect_others
, extended_select
);
2711 m_key_current
= (wxGenericTreeItem
*) prev
.m_pItem
;
2718 while ( IsExpanded(prev
) && HasChildren(prev
) )
2720 wxTreeItemId child
= GetLastChild(prev
);
2727 DoSelectItem( prev
, unselect_others
, extended_select
);
2728 m_key_current
=(wxGenericTreeItem
*) prev
.m_pItem
;
2733 // left arrow goes to the parent
2736 wxTreeItemId prev
= GetItemParent( m_current
);
2737 if ((prev
== GetRootItem()) && HasFlag(wxTR_HIDE_ROOT
))
2739 // don't go to root if it is hidden
2740 prev
= GetPrevSibling( m_current
);
2744 DoSelectItem( prev
, unselect_others
, extended_select
);
2750 // this works the same as the down arrow except that we
2751 // also expand the item if it wasn't expanded yet
2757 if (IsExpanded(m_key_current
) && HasChildren(m_key_current
))
2759 wxTreeItemIdValue cookie
;
2760 wxTreeItemId child
= GetFirstChild( m_key_current
, cookie
);
2761 DoSelectItem( child
, unselect_others
, extended_select
);
2762 m_key_current
=(wxGenericTreeItem
*) child
.m_pItem
;
2766 wxTreeItemId next
= GetNextSibling( m_key_current
);
2769 wxTreeItemId current
= m_key_current
;
2770 while (current
.IsOk() && !next
)
2772 current
= GetItemParent( current
);
2773 if (current
) next
= GetNextSibling( current
);
2778 DoSelectItem( next
, unselect_others
, extended_select
);
2779 m_key_current
=(wxGenericTreeItem
*) next
.m_pItem
;
2785 // <End> selects the last visible tree item
2788 wxTreeItemId last
= GetRootItem();
2790 while ( last
.IsOk() && IsExpanded(last
) )
2792 wxTreeItemId lastChild
= GetLastChild(last
);
2794 // it may happen if the item was expanded but then all of
2795 // its children have been deleted - so IsExpanded() returned
2796 // true, but GetLastChild() returned invalid item
2805 DoSelectItem( last
, unselect_others
, extended_select
);
2810 // <Home> selects the root item
2813 wxTreeItemId prev
= GetRootItem();
2817 if ( HasFlag(wxTR_HIDE_ROOT
) )
2819 wxTreeItemIdValue cookie
;
2820 prev
= GetFirstChild(prev
, cookie
);
2825 DoSelectItem( prev
, unselect_others
, extended_select
);
2830 // do not use wxIsalnum() here
2831 if ( !event
.HasModifiers() &&
2832 ((keyCode
>= '0' && keyCode
<= '9') ||
2833 (keyCode
>= 'a' && keyCode
<= 'z') ||
2834 (keyCode
>= 'A' && keyCode
<= 'Z' )))
2836 // find the next item starting with the given prefix
2837 wxChar ch
= (wxChar
)keyCode
;
2839 wxTreeItemId id
= FindItem(m_current
, m_findPrefix
+ ch
);
2850 // also start the timer to reset the current prefix if the user
2851 // doesn't press any more alnum keys soon -- we wouldn't want
2852 // to use this prefix for a new item search
2855 m_findTimer
= new wxTreeFindTimer(this);
2858 m_findTimer
->Start(wxTreeFindTimer
::DELAY
, wxTIMER_ONE_SHOT
);
2867 wxTreeItemId wxGenericTreeCtrl
::HitTest(const wxPoint
& point
, int& flags
)
2869 // JACS: removed wxYieldIfNeeded() because it can cause the window
2870 // to be deleted from under us if a close window event is pending
2875 if (point
.x
<0) flags
|= wxTREE_HITTEST_TOLEFT
;
2876 if (point
.x
>w
) flags
|= wxTREE_HITTEST_TORIGHT
;
2877 if (point
.y
<0) flags
|= wxTREE_HITTEST_ABOVE
;
2878 if (point
.y
>h
) flags
|= wxTREE_HITTEST_BELOW
;
2879 if (flags
) return wxTreeItemId();
2881 if (m_anchor
== NULL
)
2883 flags
= wxTREE_HITTEST_NOWHERE
;
2884 return wxTreeItemId();
2887 wxGenericTreeItem
*hit
= m_anchor
->HitTest(CalcUnscrolledPosition(point
),
2891 flags
= wxTREE_HITTEST_NOWHERE
;
2892 return wxTreeItemId();
2897 // get the bounding rectangle of the item (or of its label only)
2898 bool wxGenericTreeCtrl
::GetBoundingRect(const wxTreeItemId
& item
,
2900 bool WXUNUSED(textOnly
)) const
2902 wxCHECK_MSG( item
.IsOk(), false, _T("invalid item in wxGenericTreeCtrl::GetBoundingRect") );
2904 wxGenericTreeItem
*i
= (wxGenericTreeItem
*) item
.m_pItem
;
2907 GetViewStart(& startX
, & startY
);
2909 rect
.x
= i
->GetX() - startX
*PIXELS_PER_UNIT
;
2910 rect
.y
= i
->GetY() - startY
*PIXELS_PER_UNIT
;
2911 rect
.width
= i
->GetWidth();
2912 //rect.height = i->GetHeight();
2913 rect
.height
= GetLineHeight(i
);
2918 void wxGenericTreeCtrl
::Edit( const wxTreeItemId
& item
)
2920 wxCHECK_RET( item
.IsOk(), _T("can't edit an invalid item") );
2922 wxGenericTreeItem
*itemEdit
= (wxGenericTreeItem
*)item
.m_pItem
;
2924 wxTreeEvent
te( wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT
, GetId() );
2925 te
.m_item
= itemEdit
;
2926 te
.SetEventObject( this );
2927 if ( GetEventHandler()->ProcessEvent( te
) && !te
.IsAllowed() )
2933 // We have to call this here because the label in
2934 // question might just have been added and no screen
2935 // update taken place.
2937 #if defined( __WXMSW__ ) || defined(__WXMAC__)
2943 m_textCtrl
= new wxTreeTextCtrl(this, itemEdit
);
2945 m_textCtrl
->SetFocus();
2948 // returns a pointer to the text edit control if the item is being
2949 // edited, NULL otherwise (it's assumed that no more than one item may
2950 // be edited simultaneously)
2951 wxTextCtrl
* wxGenericTreeCtrl
::GetEditControl() const
2956 bool wxGenericTreeCtrl
::OnRenameAccept(wxGenericTreeItem
*item
,
2957 const wxString
& value
)
2959 wxTreeEvent
le( wxEVT_COMMAND_TREE_END_LABEL_EDIT
, GetId() );
2961 le
.SetEventObject( this );
2963 le
.m_editCancelled
= false;
2965 return !GetEventHandler()->ProcessEvent( le
) || le
.IsAllowed();
2968 void wxGenericTreeCtrl
::OnRenameCancelled(wxGenericTreeItem
*item
)
2970 // let owner know that the edit was cancelled
2971 wxTreeEvent
le( wxEVT_COMMAND_TREE_END_LABEL_EDIT
, GetId() );
2973 le
.SetEventObject( this );
2974 le
.m_label
= wxEmptyString
;
2975 le
.m_editCancelled
= true;
2977 GetEventHandler()->ProcessEvent( le
);
2980 void wxGenericTreeCtrl
::OnRenameTimer()
2985 void wxGenericTreeCtrl
::OnMouse( wxMouseEvent
&event
)
2987 if ( !m_anchor
) return;
2989 wxPoint pt
= CalcUnscrolledPosition(event
.GetPosition());
2991 // Is the mouse over a tree item button?
2993 wxGenericTreeItem
*thisItem
= m_anchor
->HitTest(pt
, this, flags
, 0);
2994 wxGenericTreeItem
*underMouse
= thisItem
;
2996 bool underMouseChanged
= (underMouse
!= m_underMouse
) ;
2997 #endif // wxUSE_TOOLTIPS
3000 (flags
& wxTREE_HITTEST_ONITEMBUTTON
) &&
3001 (!event
.LeftIsDown()) &&
3003 (!m_renameTimer
|| !m_renameTimer
->IsRunning()))
3011 if (underMouse
!= m_underMouse
)
3015 // unhighlight old item
3016 wxGenericTreeItem
*tmp
= m_underMouse
;
3017 m_underMouse
= NULL
;
3021 m_underMouse
= underMouse
;
3023 RefreshLine( m_underMouse
);
3027 // Determines what item we are hovering over and need a tooltip for
3028 wxTreeItemId hoverItem
= thisItem
;
3030 // We do not want a tooltip if we are dragging, or if the rename timer is running
3031 if (underMouseChanged
&& hoverItem
.IsOk() && !m_isDragging
&& (!m_renameTimer
|| !m_renameTimer
->IsRunning()))
3033 // Ask the tree control what tooltip (if any) should be shown
3034 wxTreeEvent
hevent(wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP
, GetId());
3035 hevent
.m_item
= hoverItem
;
3036 hevent
.SetEventObject(this);
3038 if ( GetEventHandler()->ProcessEvent(hevent
) && hevent
.IsAllowed() )
3040 SetToolTip(hevent
.m_label
);
3045 // we process left mouse up event (enables in-place edit), right down
3046 // (pass to the user code), left dbl click (activate item) and
3047 // dragging/moving events for items drag-and-drop
3048 if ( !(event
.LeftDown() ||
3050 event
.RightDown() ||
3051 event
.LeftDClick() ||
3053 ((event
.Moving() || event
.RightUp()) && m_isDragging
)) )
3062 wxGenericTreeItem
*item
= m_anchor
->HitTest(pt
, this, flags
, 0);
3064 if ( event
.Dragging() && !m_isDragging
)
3066 if (m_dragCount
== 0)
3071 if (m_dragCount
!= 3)
3073 // wait until user drags a bit further...
3077 wxEventType command
= event
.RightIsDown()
3078 ? wxEVT_COMMAND_TREE_BEGIN_RDRAG
3079 : wxEVT_COMMAND_TREE_BEGIN_DRAG
;
3081 wxTreeEvent
nevent( command
, GetId() );
3082 nevent
.m_item
= m_current
;
3083 nevent
.SetEventObject(this);
3085 // by default the dragging is not supported, the user code must
3086 // explicitly allow the event for it to take place
3089 if ( GetEventHandler()->ProcessEvent(nevent
) && nevent
.IsAllowed() )
3091 // we're going to drag this item
3092 m_isDragging
= true;
3094 // remember the old cursor because we will change it while
3096 m_oldCursor
= m_cursor
;
3098 // in a single selection control, hide the selection temporarily
3099 if ( !(GetWindowStyleFlag() & wxTR_MULTIPLE
) )
3101 m_oldSelection
= (wxGenericTreeItem
*) GetSelection().m_pItem
;
3103 if ( m_oldSelection
)
3105 m_oldSelection
->SetHilight(false);
3106 RefreshLine(m_oldSelection
);
3113 else if ( event
.Dragging() )
3115 if ( item
!= m_dropTarget
)
3117 // unhighlight the previous drop target
3118 DrawDropEffect(m_dropTarget
);
3120 m_dropTarget
= item
;
3122 // highlight the current drop target if any
3123 DrawDropEffect(m_dropTarget
);
3125 #if defined(__WXMSW__) || defined(__WXMAC__) || defined(__WXGTK20__)
3132 else if ( (event
.LeftUp() || event
.RightUp()) && m_isDragging
)
3134 // erase the highlighting
3135 DrawDropEffect(m_dropTarget
);
3137 if ( m_oldSelection
)
3139 m_oldSelection
->SetHilight(true);
3140 RefreshLine(m_oldSelection
);
3141 m_oldSelection
= (wxGenericTreeItem
*)NULL
;
3144 // generate the drag end event
3145 wxTreeEvent
event(wxEVT_COMMAND_TREE_END_DRAG
, GetId());
3147 event
.m_item
= item
;
3148 event
.m_pointDrag
= pt
;
3149 event
.SetEventObject(this);
3151 (void)GetEventHandler()->ProcessEvent(event
);
3153 m_isDragging
= false;
3154 m_dropTarget
= (wxGenericTreeItem
*)NULL
;
3158 SetCursor(m_oldCursor
);
3160 #if defined( __WXMSW__ ) || defined(__WXMAC__)
3168 // If we got to this point, we are not dragging or moving the mouse.
3169 // Because the code in carbon/toplevel.cpp will only set focus to the tree
3170 // if we skip for EVT_LEFT_DOWN, we MUST skip this event here for focus to work.
3171 // We skip even if we didn't hit an item because we still should
3172 // restore focus to the tree control even if we didn't exactly hit an item.
3173 if ( event
.LeftDown() )
3178 // here we process only the messages which happen on tree items
3182 if (item
== NULL
) return; /* we hit the blank area */
3184 if ( event
.RightDown() )
3186 // If the item is already selected, do not update the selection.
3187 // Multi-selections should not be cleared if a selected item is clicked.
3188 if (!IsSelected(item
))
3190 DoSelectItem(item
, true, false);
3193 wxTreeEvent
nevent(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK
, GetId());
3194 nevent
.m_item
= item
;
3195 nevent
.m_pointDrag
= CalcScrolledPosition(pt
);
3196 nevent
.SetEventObject(this);
3197 event
.Skip(!GetEventHandler()->ProcessEvent(nevent
));
3199 else if ( event
.LeftUp() )
3201 // this facilitates multiple-item drag-and-drop
3203 if (item
&& HasFlag(wxTR_MULTIPLE
))
3205 wxArrayTreeItemIds selections
;
3206 size_t count
= GetSelections(selections
);
3209 !event
.ControlDown() &&
3212 DoSelectItem(item
, true, false);
3218 if ( (item
== m_current
) &&
3219 (flags
& wxTREE_HITTEST_ONITEMLABEL
) &&
3220 HasFlag(wxTR_EDIT_LABELS
) )
3222 if ( m_renameTimer
)
3224 if ( m_renameTimer
->IsRunning() )
3225 m_renameTimer
->Stop();
3229 m_renameTimer
= new wxTreeRenameTimer( this );
3232 m_renameTimer
->Start( wxTreeRenameTimer
::DELAY
, true );
3235 m_lastOnSame
= false;
3238 else // !RightDown() && !LeftUp() ==> LeftDown() || LeftDClick()
3240 if ( event
.LeftDown() )
3242 m_lastOnSame
= item
== m_current
;
3245 if ( flags
& wxTREE_HITTEST_ONITEMBUTTON
)
3247 // only toggle the item for a single click, double click on
3248 // the button doesn't do anything (it toggles the item twice)
3249 if ( event
.LeftDown() )
3254 // don't select the item if the button was clicked
3259 // clear the previously selected items, if the
3260 // user clicked outside of the present selection.
3261 // otherwise, perform the deselection on mouse-up.
3262 // this allows multiple drag and drop to work.
3264 if (!IsSelected(item
))
3266 // how should the selection work for this event?
3267 bool is_multiple
, extended_select
, unselect_others
;
3268 EventFlagsToSelType(GetWindowStyleFlag(),
3270 event
.ControlDown(),
3271 is_multiple
, extended_select
, unselect_others
);
3273 DoSelectItem(item
, unselect_others
, extended_select
);
3277 // For some reason, Windows isn't recognizing a left double-click,
3278 // so we need to simulate it here. Allow 200 milliseconds for now.
3279 if ( event
.LeftDClick() )
3281 // double clicking should not start editing the item label
3282 if ( m_renameTimer
)
3283 m_renameTimer
->Stop();
3285 m_lastOnSame
= false;
3287 // send activate event first
3288 wxTreeEvent
nevent( wxEVT_COMMAND_TREE_ITEM_ACTIVATED
, GetId() );
3289 nevent
.m_item
= item
;
3290 nevent
.m_pointDrag
= CalcScrolledPosition(pt
);
3291 nevent
.SetEventObject( this );
3292 if ( !GetEventHandler()->ProcessEvent( nevent
) )
3294 // if the user code didn't process the activate event,
3295 // handle it ourselves by toggling the item when it is
3297 if ( item
->HasPlus() )
3307 void wxGenericTreeCtrl
::OnInternalIdle()
3309 wxWindow
::OnInternalIdle();
3311 // Check if we need to select the root item
3312 // because nothing else has been selected.
3313 // Delaying it means that we can invoke event handlers
3314 // as required, when a first item is selected.
3315 if (!HasFlag(wxTR_MULTIPLE
) && !GetSelection().IsOk())
3318 SelectItem(m_select_me
);
3319 else if (GetRootItem().IsOk())
3320 SelectItem(GetRootItem());
3323 /* after all changes have been done to the tree control,
3324 * we actually redraw the tree when everything is over */
3326 if (!m_dirty
) return;
3327 if (m_freezeCount
) return;
3331 CalculatePositions();
3333 AdjustMyScrollbars();
3336 void wxGenericTreeCtrl
::CalculateSize( wxGenericTreeItem
*item
, wxDC
&dc
)
3341 wxTreeItemAttr
*attr
= item
->GetAttributes();
3342 if ( attr
&& attr
->HasFont() )
3343 dc
.SetFont(attr
->GetFont());
3344 else if ( item
->IsBold() )
3345 dc
.SetFont(m_boldFont
);
3347 dc
.SetFont(m_normalFont
);
3349 dc
.GetTextExtent( item
->GetText(), &text_w
, &text_h
);
3352 // restore normal font
3353 dc
.SetFont( m_normalFont
);
3357 int image
= item
->GetCurrentImage();
3358 if ( image
!= NO_IMAGE
)
3360 if ( m_imageListNormal
)
3362 m_imageListNormal
->GetSize( image
, image_w
, image_h
);
3367 int total_h
= (image_h
> text_h
) ? image_h
: text_h
;
3370 total_h
+= 2; // at least 2 pixels
3372 total_h
+= total_h
/10; // otherwise 10% extra spacing
3374 item
->SetHeight(total_h
);
3375 if (total_h
>m_lineHeight
)
3376 m_lineHeight
=total_h
;
3378 item
->SetWidth(image_w
+text_w
+2);
3381 // -----------------------------------------------------------------------------
3382 // for developper : y is now the top of the level
3383 // not the middle of it !
3384 void wxGenericTreeCtrl
::CalculateLevel( wxGenericTreeItem
*item
, wxDC
&dc
, int level
, int &y
)
3386 int x
= level
*m_indent
;
3387 if (!HasFlag(wxTR_HIDE_ROOT
))
3391 else if (level
== 0)
3393 // a hidden root is not evaluated, but its
3394 // children are always calculated
3398 CalculateSize( item
, dc
);
3401 item
->SetX( x
+m_spacing
);
3403 y
+= GetLineHeight(item
);
3405 if ( !item
->IsExpanded() )
3407 // we don't need to calculate collapsed branches
3412 wxArrayGenericTreeItems
& children
= item
->GetChildren();
3413 size_t n
, count
= children
.Count();
3415 for (n
= 0; n
< count
; ++n
)
3416 CalculateLevel( children
[n
], dc
, level
, y
); // recurse
3419 void wxGenericTreeCtrl
::CalculatePositions()
3421 if ( !m_anchor
) return;
3423 wxClientDC
dc(this);
3426 dc
.SetFont( m_normalFont
);
3428 dc
.SetPen( m_dottedPen
);
3429 //if(GetImageList() == NULL)
3430 // m_lineHeight = (int)(dc.GetCharHeight() + 4);
3433 CalculateLevel( m_anchor
, dc
, 0, y
); // start recursion
3436 void wxGenericTreeCtrl
::RefreshSubtree(wxGenericTreeItem
*item
)
3438 if (m_dirty
) return;
3439 if (m_freezeCount
) return;
3441 wxSize client
= GetClientSize();
3444 CalcScrolledPosition(0, item
->GetY(), NULL
, &rect
.y
);
3445 rect
.width
= client
.x
;
3446 rect
.height
= client
.y
;
3448 Refresh(true, &rect
);
3450 AdjustMyScrollbars();
3453 void wxGenericTreeCtrl
::RefreshLine( wxGenericTreeItem
*item
)
3455 if (m_dirty
) return;
3456 if (m_freezeCount
) return;
3459 CalcScrolledPosition(0, item
->GetY(), NULL
, &rect
.y
);
3460 rect
.width
= GetClientSize().x
;
3461 rect
.height
= GetLineHeight(item
); //dc.GetCharHeight() + 6;
3463 Refresh(true, &rect
);
3466 void wxGenericTreeCtrl
::RefreshSelected()
3468 if (m_freezeCount
) return;
3470 // TODO: this is awfully inefficient, we should keep the list of all
3471 // selected items internally, should be much faster
3473 RefreshSelectedUnder(m_anchor
);
3476 void wxGenericTreeCtrl
::RefreshSelectedUnder(wxGenericTreeItem
*item
)
3478 if (m_freezeCount
) return;
3480 if ( item
->IsSelected() )
3483 const wxArrayGenericTreeItems
& children
= item
->GetChildren();
3484 size_t count
= children
.GetCount();
3485 for ( size_t n
= 0; n
< count
; n
++ )
3487 RefreshSelectedUnder(children
[n
]);
3491 void wxGenericTreeCtrl
::Freeze()
3496 void wxGenericTreeCtrl
::Thaw()
3498 wxCHECK_RET( m_freezeCount
> 0, _T("thawing unfrozen tree control?") );
3500 if ( !--m_freezeCount
)
3506 // ----------------------------------------------------------------------------
3507 // changing colours: we need to refresh the tree control
3508 // ----------------------------------------------------------------------------
3510 bool wxGenericTreeCtrl
::SetBackgroundColour(const wxColour
& colour
)
3512 if ( !wxWindow
::SetBackgroundColour(colour
) )
3515 if (m_freezeCount
) return true;
3522 bool wxGenericTreeCtrl
::SetForegroundColour(const wxColour
& colour
)
3524 if ( !wxWindow
::SetForegroundColour(colour
) )
3527 if (m_freezeCount
) return true;
3534 // Process the tooltip event, to speed up event processing.
3535 // Doesn't actually get a tooltip.
3536 void wxGenericTreeCtrl
::OnGetToolTip( wxTreeEvent
&event
)
3542 wxSize wxGenericTreeCtrl
::DoGetBestSize() const
3544 // something is better than nothing...
3545 // 100x80 is what the MSW version will get from the default
3546 // wxControl::DoGetBestSize
3547 return wxSize(100,80);
3551 // NOTE: If using the wxListBox visual attributes works everywhere then this can
3552 // be removed, as well as the #else case below.
3553 #define _USE_VISATTR 0
3556 #include "wx/listbox.h"
3562 wxGenericTreeCtrl
::GetClassDefaultAttributes(wxWindowVariant variant
)
3564 wxGenericTreeCtrl
::GetClassDefaultAttributes(wxWindowVariant
WXUNUSED(variant
))
3568 // Use the same color scheme as wxListBox
3569 return wxListBox
::GetClassDefaultAttributes(variant
);
3571 wxVisualAttributes attr
;
3572 attr
.colFg
= wxSystemSettings
::GetColour(wxSYS_COLOUR_WINDOWTEXT
);
3573 attr
.colBg
= wxSystemSettings
::GetColour(wxSYS_COLOUR_LISTBOX
);
3574 attr
.font
= wxSystemSettings
::GetFont(wxSYS_DEFAULT_GUI_FONT
);
3579 #if WXWIN_COMPATIBILITY_2_4
3581 int wxGenericTreeCtrl
::GetItemSelectedImage(const wxTreeItemId
& item
) const
3583 return GetItemImage(item
, wxTreeItemIcon_Selected
);
3586 void wxGenericTreeCtrl
::SetItemSelectedImage(const wxTreeItemId
& item
, int image
)
3588 SetItemImage(item
, image
, wxTreeItemIcon_Selected
);
3591 #endif // WXWIN_COMPATIBILITY_2_4
3593 #if WXWIN_COMPATIBILITY_2_2
3595 wxTreeItemId wxGenericTreeCtrl
::GetParent(const wxTreeItemId
& item
) const
3597 return GetItemParent( item
);
3600 #endif // WXWIN_COMPATIBILITY_2_2
3602 #endif // wxUSE_TREECTRL