]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/generic/treectlg.cpp
[ 1509599 ] 'Split pickers page in widgets sample' with more icons and rebaking.
[wxWidgets.git] / src / generic / treectlg.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/generic/treectlg.cpp
3// Purpose: generic tree control implementation
4// Author: Robert Roebling
5// Created: 01/02/97
6// Modified: 22/10/98 - almost total rewrite, simpler interface (VZ)
7// Id: $Id$
8// Copyright: (c) 1998 Robert Roebling and Julian Smart
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12// =============================================================================
13// declarations
14// =============================================================================
15
16// -----------------------------------------------------------------------------
17// headers
18// -----------------------------------------------------------------------------
19
20// For compilers that support precompilation, includes "wx.h".
21#include "wx/wxprec.h"
22
23#ifdef __BORLANDC__
24 #pragma hdrstop
25#endif
26
27#if wxUSE_TREECTRL
28
29#include "wx/treectrl.h"
30
31#ifndef WX_PRECOMP
32 #include "wx/dcclient.h"
33 #include "wx/timer.h"
34 #include "wx/settings.h"
35 #include "wx/listbox.h"
36 #include "wx/textctrl.h"
37#endif
38
39#include "wx/generic/treectlg.h"
40#include "wx/imaglist.h"
41
42#include "wx/renderer.h"
43
44#ifdef __WXMAC__
45 #include "wx/mac/private.h"
46#endif
47
48// -----------------------------------------------------------------------------
49// array types
50// -----------------------------------------------------------------------------
51
52class WXDLLEXPORT wxGenericTreeItem;
53
54WX_DEFINE_EXPORTED_ARRAY_PTR(wxGenericTreeItem *, wxArrayGenericTreeItems);
55
56// ----------------------------------------------------------------------------
57// constants
58// ----------------------------------------------------------------------------
59
60static const int NO_IMAGE = -1;
61
62static const int PIXELS_PER_UNIT = 10;
63
64// the margin between the item image and the item text
65static const int MARGIN_BETWEEN_IMAGE_AND_TEXT = 4;
66
67// -----------------------------------------------------------------------------
68// private classes
69// -----------------------------------------------------------------------------
70
71// timer used for enabling in-place edit
72class WXDLLEXPORT wxTreeRenameTimer: public wxTimer
73{
74public:
75 // start editing the current item after half a second (if the mouse hasn't
76 // been clicked/moved)
77 enum { DELAY = 500 };
78
79 wxTreeRenameTimer( wxGenericTreeCtrl *owner );
80
81 virtual void Notify();
82
83private:
84 wxGenericTreeCtrl *m_owner;
85
86 DECLARE_NO_COPY_CLASS(wxTreeRenameTimer)
87};
88
89// control used for in-place edit
90class WXDLLEXPORT wxTreeTextCtrl: public wxTextCtrl
91{
92public:
93 wxTreeTextCtrl(wxGenericTreeCtrl *owner, wxGenericTreeItem *item);
94
95 void EndEdit(bool discardChanges = false)
96 {
97 if ( discardChanges )
98 {
99 StopEditing();
100 }
101 else
102 {
103 m_aboutToFinish = true;
104
105 // Notify the owner about the changes
106 AcceptChanges();
107
108 // Even if vetoed, close the control (consistent with MSW)
109 Finish();
110 }
111 }
112
113 void StopEditing()
114 {
115 Finish();
116 m_owner->OnRenameCancelled(m_itemEdited);
117 }
118 const wxGenericTreeItem* item() const { return m_itemEdited; }
119
120protected:
121 void OnChar( wxKeyEvent &event );
122 void OnKeyUp( wxKeyEvent &event );
123 void OnKillFocus( wxFocusEvent &event );
124
125 bool AcceptChanges();
126 void Finish();
127
128private:
129 wxGenericTreeCtrl *m_owner;
130 wxGenericTreeItem *m_itemEdited;
131 wxString m_startValue;
132 bool m_finished;
133 bool m_aboutToFinish;
134
135 DECLARE_EVENT_TABLE()
136 DECLARE_NO_COPY_CLASS(wxTreeTextCtrl)
137};
138
139// timer used to clear wxGenericTreeCtrl::m_findPrefix if no key was pressed
140// for a sufficiently long time
141class WXDLLEXPORT wxTreeFindTimer : public wxTimer
142{
143public:
144 // reset the current prefix after half a second of inactivity
145 enum { DELAY = 500 };
146
147 wxTreeFindTimer( wxGenericTreeCtrl *owner ) { m_owner = owner; }
148
149 virtual void Notify() { m_owner->m_findPrefix.clear(); }
150
151private:
152 wxGenericTreeCtrl *m_owner;
153
154 DECLARE_NO_COPY_CLASS(wxTreeFindTimer)
155};
156
157// a tree item
158class WXDLLEXPORT wxGenericTreeItem
159{
160public:
161 // ctors & dtor
162 wxGenericTreeItem() { m_data = NULL; }
163 wxGenericTreeItem( wxGenericTreeItem *parent,
164 const wxString& text,
165 int image,
166 int selImage,
167 wxTreeItemData *data );
168
169 ~wxGenericTreeItem();
170
171 // trivial accessors
172 wxArrayGenericTreeItems& GetChildren() { return m_children; }
173
174 const wxString& GetText() const { return m_text; }
175 int GetImage(wxTreeItemIcon which = wxTreeItemIcon_Normal) const
176 { return m_images[which]; }
177 wxTreeItemData *GetData() const { return m_data; }
178
179 // returns the current image for the item (depending on its
180 // selected/expanded/whatever state)
181 int GetCurrentImage() const;
182
183 void SetText( const wxString &text );
184 void SetImage(int image, wxTreeItemIcon which) { m_images[which] = image; }
185 void SetData(wxTreeItemData *data) { m_data = data; }
186
187 void SetHasPlus(bool has = true) { m_hasPlus = has; }
188
189 void SetBold(bool bold) { m_isBold = bold; }
190
191 int GetX() const { return m_x; }
192 int GetY() const { return m_y; }
193
194 void SetX(int x) { m_x = x; }
195 void SetY(int y) { m_y = y; }
196
197 int GetHeight() const { return m_height; }
198 int GetWidth() const { return m_width; }
199
200 void SetHeight(int h) { m_height = h; }
201 void SetWidth(int w) { m_width = w; }
202
203 wxGenericTreeItem *GetParent() const { return m_parent; }
204
205 // operations
206
207 // deletes all children notifying the treectrl about it
208 void DeleteChildren(wxGenericTreeCtrl *tree);
209
210 // get count of all children (and grand children if 'recursively')
211 size_t GetChildrenCount(bool recursively = true) const;
212
213 void Insert(wxGenericTreeItem *child, size_t index)
214 { m_children.Insert(child, index); }
215
216 void GetSize( int &x, int &y, const wxGenericTreeCtrl* );
217
218 // return the item at given position (or NULL if no item), onButton is
219 // true if the point belongs to the item's button, otherwise it lies
220 // on the item's label
221 wxGenericTreeItem *HitTest( const wxPoint& point,
222 const wxGenericTreeCtrl *,
223 int &flags,
224 int level );
225
226 void Expand() { m_isCollapsed = false; }
227 void Collapse() { m_isCollapsed = true; }
228
229 void SetHilight( bool set = true ) { m_hasHilight = set; }
230
231 // status inquiries
232 bool HasChildren() const { return !m_children.IsEmpty(); }
233 bool IsSelected() const { return m_hasHilight != 0; }
234 bool IsExpanded() const { return !m_isCollapsed; }
235 bool HasPlus() const { return m_hasPlus || HasChildren(); }
236 bool IsBold() const { return m_isBold != 0; }
237
238 // attributes
239 // get them - may be NULL
240 wxTreeItemAttr *GetAttributes() const { return m_attr; }
241 // get them ensuring that the pointer is not NULL
242 wxTreeItemAttr& Attr()
243 {
244 if ( !m_attr )
245 {
246 m_attr = new wxTreeItemAttr;
247 m_ownsAttr = true;
248 }
249 return *m_attr;
250 }
251 // set them
252 void SetAttributes(wxTreeItemAttr *attr)
253 {
254 if ( m_ownsAttr ) delete m_attr;
255 m_attr = attr;
256 m_ownsAttr = false;
257 }
258 // set them and delete when done
259 void AssignAttributes(wxTreeItemAttr *attr)
260 {
261 SetAttributes(attr);
262 m_ownsAttr = true;
263 }
264
265private:
266 // since there can be very many of these, we save size by chosing
267 // the smallest representation for the elements and by ordering
268 // the members to avoid padding.
269 wxString m_text; // label to be rendered for item
270
271 wxTreeItemData *m_data; // user-provided data
272
273 wxArrayGenericTreeItems m_children; // list of children
274 wxGenericTreeItem *m_parent; // parent of this item
275
276 wxTreeItemAttr *m_attr; // attributes???
277
278 // tree ctrl images for the normal, selected, expanded and
279 // expanded+selected states
280 int m_images[wxTreeItemIcon_Max];
281
282 wxCoord m_x; // (virtual) offset from top
283 wxCoord m_y; // (virtual) offset from left
284 int m_width; // width of this item
285 int m_height; // height of this item
286
287 // use bitfields to save size
288 unsigned int m_isCollapsed :1;
289 unsigned int m_hasHilight :1; // same as focused
290 unsigned int m_hasPlus :1; // used for item which doesn't have
291 // children but has a [+] button
292 unsigned int m_isBold :1; // render the label in bold font
293 unsigned int m_ownsAttr :1; // delete attribute when done
294
295 DECLARE_NO_COPY_CLASS(wxGenericTreeItem)
296};
297
298// =============================================================================
299// implementation
300// =============================================================================
301
302// ----------------------------------------------------------------------------
303// private functions
304// ----------------------------------------------------------------------------
305
306// translate the key or mouse event flags to the type of selection we're
307// dealing with
308static void EventFlagsToSelType(long style,
309 bool shiftDown,
310 bool ctrlDown,
311 bool &is_multiple,
312 bool &extended_select,
313 bool &unselect_others)
314{
315 is_multiple = (style & wxTR_MULTIPLE) != 0;
316 extended_select = shiftDown && is_multiple;
317 unselect_others = !(extended_select || (ctrlDown && is_multiple));
318}
319
320// check if the given item is under another one
321static bool IsDescendantOf(const wxGenericTreeItem *parent, const wxGenericTreeItem *item)
322{
323 while ( item )
324 {
325 if ( item == parent )
326 {
327 // item is a descendant of parent
328 return true;
329 }
330
331 item = item->GetParent();
332 }
333
334 return false;
335}
336
337// -----------------------------------------------------------------------------
338// wxTreeRenameTimer (internal)
339// -----------------------------------------------------------------------------
340
341wxTreeRenameTimer::wxTreeRenameTimer( wxGenericTreeCtrl *owner )
342{
343 m_owner = owner;
344}
345
346void wxTreeRenameTimer::Notify()
347{
348 m_owner->OnRenameTimer();
349}
350
351//-----------------------------------------------------------------------------
352// wxTreeTextCtrl (internal)
353//-----------------------------------------------------------------------------
354
355BEGIN_EVENT_TABLE(wxTreeTextCtrl,wxTextCtrl)
356 EVT_CHAR (wxTreeTextCtrl::OnChar)
357 EVT_KEY_UP (wxTreeTextCtrl::OnKeyUp)
358 EVT_KILL_FOCUS (wxTreeTextCtrl::OnKillFocus)
359END_EVENT_TABLE()
360
361wxTreeTextCtrl::wxTreeTextCtrl(wxGenericTreeCtrl *owner,
362 wxGenericTreeItem *item)
363 : m_itemEdited(item), m_startValue(item->GetText())
364{
365 m_owner = owner;
366 m_finished = false;
367 m_aboutToFinish = false;
368
369 int w = m_itemEdited->GetWidth(),
370 h = m_itemEdited->GetHeight();
371
372 int x, y;
373 m_owner->CalcScrolledPosition(item->GetX(), item->GetY(), &x, &y);
374
375 int image_h = 0,
376 image_w = 0;
377
378 int image = item->GetCurrentImage();
379 if ( image != NO_IMAGE )
380 {
381 if ( m_owner->m_imageListNormal )
382 {
383 m_owner->m_imageListNormal->GetSize( image, image_w, image_h );
384 image_w += MARGIN_BETWEEN_IMAGE_AND_TEXT;
385 }
386 else
387 {
388 wxFAIL_MSG(_T("you must create an image list to use images!"));
389 }
390 }
391
392 // FIXME: what are all these hardcoded 4, 8 and 11s really?
393 x += image_w;
394 w -= image_w + 4;
395#ifdef __WXMAC__
396 wxSize bs = DoGetBestSize() ;
397 // edit control height
398 if ( h > bs.y - 8 )
399 {
400 int diff = h - ( bs.y - 8 ) ;
401 h -= diff ;
402 y += diff / 2 ;
403 }
404#endif
405
406 (void)Create(m_owner, wxID_ANY, m_startValue,
407 wxPoint(x - 4, y - 4), wxSize(w + 11, h + 8));
408}
409
410bool wxTreeTextCtrl::AcceptChanges()
411{
412 const wxString value = GetValue();
413
414 if ( value == m_startValue )
415 {
416 // nothing changed, always accept
417 // when an item remains unchanged, the owner
418 // needs to be notified that the user decided
419 // not to change the tree item label, and that
420 // the edit has been cancelled
421
422 m_owner->OnRenameCancelled(m_itemEdited);
423 return true;
424 }
425
426 if ( !m_owner->OnRenameAccept(m_itemEdited, value) )
427 {
428 // vetoed by the user
429 return false;
430 }
431
432 // accepted, do rename the item
433 m_owner->SetItemText(m_itemEdited, value);
434
435 return true;
436}
437
438void wxTreeTextCtrl::Finish()
439{
440 if ( !m_finished )
441 {
442 m_owner->ResetTextControl();
443
444 wxPendingDelete.Append(this);
445
446 m_finished = true;
447
448 m_owner->SetFocus();
449 }
450}
451
452void wxTreeTextCtrl::OnChar( wxKeyEvent &event )
453{
454 switch ( event.m_keyCode )
455 {
456 case WXK_RETURN:
457 EndEdit();
458 break;
459
460 case WXK_ESCAPE:
461 StopEditing();
462 break;
463
464 default:
465 event.Skip();
466 }
467}
468
469void wxTreeTextCtrl::OnKeyUp( wxKeyEvent &event )
470{
471 if ( !m_finished )
472 {
473 // auto-grow the textctrl:
474 wxSize parentSize = m_owner->GetSize();
475 wxPoint myPos = GetPosition();
476 wxSize mySize = GetSize();
477 int sx, sy;
478 GetTextExtent(GetValue() + _T("M"), &sx, &sy);
479 if (myPos.x + sx > parentSize.x)
480 sx = parentSize.x - myPos.x;
481 if (mySize.x > sx)
482 sx = mySize.x;
483 SetSize(sx, wxDefaultCoord);
484 }
485
486 event.Skip();
487}
488
489void wxTreeTextCtrl::OnKillFocus( wxFocusEvent &event )
490{
491 if ( !m_finished && !m_aboutToFinish )
492 {
493 // We must finish regardless of success, otherwise we'll get
494 // focus problems:
495 Finish();
496
497 if ( !AcceptChanges() )
498 m_owner->OnRenameCancelled( m_itemEdited );
499 }
500
501 // We must let the native text control handle focus, too, otherwise
502 // it could have problems with the cursor (e.g., in wxGTK).
503 event.Skip();
504}
505
506// -----------------------------------------------------------------------------
507// wxGenericTreeItem
508// -----------------------------------------------------------------------------
509
510wxGenericTreeItem::wxGenericTreeItem(wxGenericTreeItem *parent,
511 const wxString& text,
512 int image, int selImage,
513 wxTreeItemData *data)
514 : m_text(text)
515{
516 m_images[wxTreeItemIcon_Normal] = image;
517 m_images[wxTreeItemIcon_Selected] = selImage;
518 m_images[wxTreeItemIcon_Expanded] = NO_IMAGE;
519 m_images[wxTreeItemIcon_SelectedExpanded] = NO_IMAGE;
520
521 m_data = data;
522 m_x = m_y = 0;
523
524 m_isCollapsed = true;
525 m_hasHilight = false;
526 m_hasPlus = false;
527 m_isBold = false;
528
529 m_parent = parent;
530
531 m_attr = (wxTreeItemAttr *)NULL;
532 m_ownsAttr = false;
533
534 // We don't know the height here yet.
535 m_width = 0;
536 m_height = 0;
537}
538
539wxGenericTreeItem::~wxGenericTreeItem()
540{
541 delete m_data;
542
543 if (m_ownsAttr) delete m_attr;
544
545 wxASSERT_MSG( m_children.IsEmpty(),
546 wxT("please call DeleteChildren() before deleting the item") );
547}
548
549void wxGenericTreeItem::DeleteChildren(wxGenericTreeCtrl *tree)
550{
551 size_t count = m_children.Count();
552 for ( size_t n = 0; n < count; n++ )
553 {
554 wxGenericTreeItem *child = m_children[n];
555 tree->SendDeleteEvent(child);
556
557 child->DeleteChildren(tree);
558 if ( child == tree->m_select_me )
559 tree->m_select_me = NULL;
560 delete child;
561 }
562
563 m_children.Empty();
564}
565
566void wxGenericTreeItem::SetText( const wxString &text )
567{
568 m_text = text;
569}
570
571size_t wxGenericTreeItem::GetChildrenCount(bool recursively) const
572{
573 size_t count = m_children.Count();
574 if ( !recursively )
575 return count;
576
577 size_t total = count;
578 for (size_t n = 0; n < count; ++n)
579 {
580 total += m_children[n]->GetChildrenCount();
581 }
582
583 return total;
584}
585
586void wxGenericTreeItem::GetSize( int &x, int &y,
587 const wxGenericTreeCtrl *theButton )
588{
589 int bottomY=m_y+theButton->GetLineHeight(this);
590 if ( y < bottomY ) y = bottomY;
591 int width = m_x + m_width;
592 if ( x < width ) x = width;
593
594 if (IsExpanded())
595 {
596 size_t count = m_children.Count();
597 for ( size_t n = 0; n < count; ++n )
598 {
599 m_children[n]->GetSize( x, y, theButton );
600 }
601 }
602}
603
604wxGenericTreeItem *wxGenericTreeItem::HitTest(const wxPoint& point,
605 const wxGenericTreeCtrl *theCtrl,
606 int &flags,
607 int level)
608{
609 // for a hidden root node, don't evaluate it, but do evaluate children
610 if ( !(level == 0 && theCtrl->HasFlag(wxTR_HIDE_ROOT)) )
611 {
612 // evaluate the item
613 int h = theCtrl->GetLineHeight(this);
614 if ((point.y > m_y) && (point.y < m_y + h))
615 {
616 int y_mid = m_y + h/2;
617 if (point.y < y_mid )
618 flags |= wxTREE_HITTEST_ONITEMUPPERPART;
619 else
620 flags |= wxTREE_HITTEST_ONITEMLOWERPART;
621
622 int xCross = m_x - theCtrl->GetSpacing();
623#ifdef __WXMAC__
624 // according to the drawing code the triangels are drawn
625 // at -4 , -4 from the position up to +10/+10 max
626 if ((point.x > xCross-4) && (point.x < xCross+10) &&
627 (point.y > y_mid-4) && (point.y < y_mid+10) &&
628 HasPlus() && theCtrl->HasButtons() )
629#else
630 // 5 is the size of the plus sign
631 if ((point.x > xCross-6) && (point.x < xCross+6) &&
632 (point.y > y_mid-6) && (point.y < y_mid+6) &&
633 HasPlus() && theCtrl->HasButtons() )
634#endif
635 {
636 flags |= wxTREE_HITTEST_ONITEMBUTTON;
637 return this;
638 }
639
640 if ((point.x >= m_x) && (point.x <= m_x+m_width))
641 {
642 int image_w = -1;
643 int image_h;
644
645 // assuming every image (normal and selected) has the same size!
646 if ( (GetImage() != NO_IMAGE) && theCtrl->m_imageListNormal )
647 theCtrl->m_imageListNormal->GetSize(GetImage(),
648 image_w, image_h);
649
650 if ((image_w != -1) && (point.x <= m_x + image_w + 1))
651 flags |= wxTREE_HITTEST_ONITEMICON;
652 else
653 flags |= wxTREE_HITTEST_ONITEMLABEL;
654
655 return this;
656 }
657
658 if (point.x < m_x)
659 flags |= wxTREE_HITTEST_ONITEMINDENT;
660 if (point.x > m_x+m_width)
661 flags |= wxTREE_HITTEST_ONITEMRIGHT;
662
663 return this;
664 }
665
666 // if children are expanded, fall through to evaluate them
667 if (m_isCollapsed) return (wxGenericTreeItem*) NULL;
668 }
669
670 // evaluate children
671 size_t count = m_children.Count();
672 for ( size_t n = 0; n < count; n++ )
673 {
674 wxGenericTreeItem *res = m_children[n]->HitTest( point,
675 theCtrl,
676 flags,
677 level + 1 );
678 if ( res != NULL )
679 return res;
680 }
681
682 return (wxGenericTreeItem*) NULL;
683}
684
685int wxGenericTreeItem::GetCurrentImage() const
686{
687 int image = NO_IMAGE;
688 if ( IsExpanded() )
689 {
690 if ( IsSelected() )
691 {
692 image = GetImage(wxTreeItemIcon_SelectedExpanded);
693 }
694
695 if ( image == NO_IMAGE )
696 {
697 // we usually fall back to the normal item, but try just the
698 // expanded one (and not selected) first in this case
699 image = GetImage(wxTreeItemIcon_Expanded);
700 }
701 }
702 else // not expanded
703 {
704 if ( IsSelected() )
705 image = GetImage(wxTreeItemIcon_Selected);
706 }
707
708 // maybe it doesn't have the specific image we want,
709 // try the default one instead
710 if ( image == NO_IMAGE ) image = GetImage();
711
712 return image;
713}
714
715// -----------------------------------------------------------------------------
716// wxGenericTreeCtrl implementation
717// -----------------------------------------------------------------------------
718
719IMPLEMENT_DYNAMIC_CLASS(wxGenericTreeCtrl, wxControl)
720
721BEGIN_EVENT_TABLE(wxGenericTreeCtrl, wxTreeCtrlBase)
722 EVT_PAINT (wxGenericTreeCtrl::OnPaint)
723 EVT_MOUSE_EVENTS (wxGenericTreeCtrl::OnMouse)
724 EVT_CHAR (wxGenericTreeCtrl::OnChar)
725 EVT_SET_FOCUS (wxGenericTreeCtrl::OnSetFocus)
726 EVT_KILL_FOCUS (wxGenericTreeCtrl::OnKillFocus)
727 EVT_TREE_ITEM_GETTOOLTIP(wxID_ANY, wxGenericTreeCtrl::OnGetToolTip)
728END_EVENT_TABLE()
729
730#if !defined(__WXMSW__) || defined(__WXUNIVERSAL__)
731/*
732 * wxTreeCtrl has to be a real class or we have problems with
733 * the run-time information.
734 */
735
736IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxGenericTreeCtrl)
737#endif
738
739// -----------------------------------------------------------------------------
740// construction/destruction
741// -----------------------------------------------------------------------------
742
743void wxGenericTreeCtrl::Init()
744{
745 m_current =
746 m_key_current =
747 m_anchor =
748 m_select_me = (wxGenericTreeItem *) NULL;
749 m_hasFocus = false;
750 m_dirty = false;
751
752 m_lineHeight = 10;
753 m_indent = 15;
754 m_spacing = 18;
755
756 m_hilightBrush = new wxBrush
757 (
758 wxSystemSettings::GetColour
759 (
760 wxSYS_COLOUR_HIGHLIGHT
761 ),
762 wxSOLID
763 );
764
765 m_hilightUnfocusedBrush = new wxBrush
766 (
767 wxSystemSettings::GetColour
768 (
769 wxSYS_COLOUR_BTNSHADOW
770 ),
771 wxSOLID
772 );
773
774 m_imageListButtons = NULL;
775 m_ownsImageListButtons = false;
776
777 m_dragCount = 0;
778 m_isDragging = false;
779 m_dropTarget = m_oldSelection = NULL;
780 m_underMouse = NULL;
781 m_textCtrl = NULL;
782
783 m_renameTimer = NULL;
784 m_freezeCount = 0;
785
786 m_findTimer = NULL;
787
788 m_dropEffectAboveItem = false;
789
790 m_lastOnSame = false;
791
792#ifdef __WXMAC_CARBON__
793 m_normalFont.MacCreateThemeFont( kThemeViewsFont ) ;
794#else
795 m_normalFont = wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT );
796#endif
797 m_boldFont = wxFont(m_normalFont.GetPointSize(),
798 m_normalFont.GetFamily(),
799 m_normalFont.GetStyle(),
800 wxBOLD,
801 m_normalFont.GetUnderlined(),
802 m_normalFont.GetFaceName(),
803 m_normalFont.GetEncoding());
804}
805
806bool wxGenericTreeCtrl::Create(wxWindow *parent,
807 wxWindowID id,
808 const wxPoint& pos,
809 const wxSize& size,
810 long style,
811 const wxValidator& validator,
812 const wxString& name )
813{
814#ifdef __WXMAC__
815 int major,minor;
816 wxGetOsVersion( &major, &minor );
817
818 style &= ~wxTR_LINES_AT_ROOT;
819 style |= wxTR_NO_LINES;
820 if (major < 10)
821 style |= wxTR_ROW_LINES;
822#endif // __WXMAC__
823
824 if ( !wxControl::Create( parent, id, pos, size,
825 style|wxHSCROLL|wxVSCROLL,
826 validator,
827 name ) )
828 return false;
829
830 // If the tree display has no buttons, but does have
831 // connecting lines, we can use a narrower layout.
832 // It may not be a good idea to force this...
833 if (!HasButtons() && !HasFlag(wxTR_NO_LINES))
834 {
835 m_indent= 10;
836 m_spacing = 10;
837 }
838
839 wxVisualAttributes attr = GetDefaultAttributes();
840 SetOwnForegroundColour( attr.colFg );
841 SetOwnBackgroundColour( attr.colBg );
842 if (!m_hasFont)
843 SetOwnFont(attr.font);
844
845 m_dottedPen = wxPen( wxT("grey"), 0, 0 );
846
847 SetBestSize(size);
848
849 return true;
850}
851
852wxGenericTreeCtrl::~wxGenericTreeCtrl()
853{
854 delete m_hilightBrush;
855 delete m_hilightUnfocusedBrush;
856
857 DeleteAllItems();
858
859 delete m_renameTimer;
860 delete m_findTimer;
861
862 if (m_ownsImageListButtons)
863 delete m_imageListButtons;
864}
865
866// -----------------------------------------------------------------------------
867// accessors
868// -----------------------------------------------------------------------------
869
870unsigned int wxGenericTreeCtrl::GetCount() const
871{
872 if ( !m_anchor )
873 {
874 // the tree is empty
875 return 0;
876 }
877
878 unsigned int count = m_anchor->GetChildrenCount();
879 if ( !HasFlag(wxTR_HIDE_ROOT) )
880 {
881 // take the root itself into account
882 count++;
883 }
884
885 return count;
886}
887
888void wxGenericTreeCtrl::SetIndent(unsigned int indent)
889{
890 m_indent = (unsigned short) indent;
891 m_dirty = true;
892}
893
894size_t
895wxGenericTreeCtrl::GetChildrenCount(const wxTreeItemId& item,
896 bool recursively) const
897{
898 wxCHECK_MSG( item.IsOk(), 0u, wxT("invalid tree item") );
899
900 return ((wxGenericTreeItem*) item.m_pItem)->GetChildrenCount(recursively);
901}
902
903void wxGenericTreeCtrl::SetWindowStyle(const long styles)
904{
905 // Do not try to expand the root node if it hasn't been created yet
906 if (m_anchor && !HasFlag(wxTR_HIDE_ROOT) && (styles & wxTR_HIDE_ROOT))
907 {
908 // if we will hide the root, make sure children are visible
909 m_anchor->SetHasPlus();
910 m_anchor->Expand();
911 CalculatePositions();
912 }
913
914 // right now, just sets the styles. Eventually, we may
915 // want to update the inherited styles, but right now
916 // none of the parents has updatable styles
917 m_windowStyle = styles;
918 m_dirty = true;
919}
920
921// -----------------------------------------------------------------------------
922// functions to work with tree items
923// -----------------------------------------------------------------------------
924
925wxString wxGenericTreeCtrl::GetItemText(const wxTreeItemId& item) const
926{
927 wxCHECK_MSG( item.IsOk(), wxEmptyString, wxT("invalid tree item") );
928
929 return ((wxGenericTreeItem*) item.m_pItem)->GetText();
930}
931
932int wxGenericTreeCtrl::GetItemImage(const wxTreeItemId& item,
933 wxTreeItemIcon which) const
934{
935 wxCHECK_MSG( item.IsOk(), -1, wxT("invalid tree item") );
936
937 return ((wxGenericTreeItem*) item.m_pItem)->GetImage(which);
938}
939
940wxTreeItemData *wxGenericTreeCtrl::GetItemData(const wxTreeItemId& item) const
941{
942 wxCHECK_MSG( item.IsOk(), NULL, wxT("invalid tree item") );
943
944 return ((wxGenericTreeItem*) item.m_pItem)->GetData();
945}
946
947wxColour wxGenericTreeCtrl::GetItemTextColour(const wxTreeItemId& item) const
948{
949 wxCHECK_MSG( item.IsOk(), wxNullColour, wxT("invalid tree item") );
950
951 wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
952 return pItem->Attr().GetTextColour();
953}
954
955wxColour wxGenericTreeCtrl::GetItemBackgroundColour(const wxTreeItemId& item) const
956{
957 wxCHECK_MSG( item.IsOk(), wxNullColour, wxT("invalid tree item") );
958
959 wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
960 return pItem->Attr().GetBackgroundColour();
961}
962
963wxFont wxGenericTreeCtrl::GetItemFont(const wxTreeItemId& item) const
964{
965 wxCHECK_MSG( item.IsOk(), wxNullFont, wxT("invalid tree item") );
966
967 wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
968 return pItem->Attr().GetFont();
969}
970
971void wxGenericTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text)
972{
973 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
974
975 wxClientDC dc(this);
976 wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
977 pItem->SetText(text);
978 CalculateSize(pItem, dc);
979 RefreshLine(pItem);
980}
981
982void wxGenericTreeCtrl::SetItemImage(const wxTreeItemId& item,
983 int image,
984 wxTreeItemIcon which)
985{
986 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
987
988 wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
989 pItem->SetImage(image, which);
990
991 wxClientDC dc(this);
992 CalculateSize(pItem, dc);
993 RefreshLine(pItem);
994}
995
996void wxGenericTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data)
997{
998 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
999
1000 if (data)
1001 data->SetId( item );
1002
1003 ((wxGenericTreeItem*) item.m_pItem)->SetData(data);
1004}
1005
1006void wxGenericTreeCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
1007{
1008 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1009
1010 wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
1011 pItem->SetHasPlus(has);
1012 RefreshLine(pItem);
1013}
1014
1015void wxGenericTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
1016{
1017 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1018
1019 // avoid redrawing the tree if no real change
1020 wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
1021 if ( pItem->IsBold() != bold )
1022 {
1023 pItem->SetBold(bold);
1024 RefreshLine(pItem);
1025 }
1026}
1027
1028void wxGenericTreeCtrl::SetItemDropHighlight(const wxTreeItemId& item,
1029 bool highlight)
1030{
1031 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1032
1033 wxColour fg, bg;
1034
1035 if (highlight)
1036 {
1037 bg = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
1038 fg = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
1039 }
1040
1041 wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
1042 pItem->Attr().SetTextColour(fg);
1043 pItem->Attr().SetBackgroundColour(bg);
1044 RefreshLine(pItem);
1045}
1046
1047void wxGenericTreeCtrl::SetItemTextColour(const wxTreeItemId& item,
1048 const wxColour& col)
1049{
1050 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1051
1052 wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
1053 pItem->Attr().SetTextColour(col);
1054 RefreshLine(pItem);
1055}
1056
1057void wxGenericTreeCtrl::SetItemBackgroundColour(const wxTreeItemId& item,
1058 const wxColour& col)
1059{
1060 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1061
1062 wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
1063 pItem->Attr().SetBackgroundColour(col);
1064 RefreshLine(pItem);
1065}
1066
1067void wxGenericTreeCtrl::SetItemFont(const wxTreeItemId& item, const wxFont& font)
1068{
1069 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1070
1071 wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
1072 pItem->Attr().SetFont(font);
1073 RefreshLine(pItem);
1074}
1075
1076bool wxGenericTreeCtrl::SetFont( const wxFont &font )
1077{
1078 wxTreeCtrlBase::SetFont(font);
1079
1080 m_normalFont = font ;
1081 m_boldFont = wxFont(m_normalFont.GetPointSize(),
1082 m_normalFont.GetFamily(),
1083 m_normalFont.GetStyle(),
1084 wxBOLD,
1085 m_normalFont.GetUnderlined(),
1086 m_normalFont.GetFaceName(),
1087 m_normalFont.GetEncoding());
1088
1089 return true;
1090}
1091
1092
1093// -----------------------------------------------------------------------------
1094// item status inquiries
1095// -----------------------------------------------------------------------------
1096
1097bool wxGenericTreeCtrl::IsVisible(const wxTreeItemId& item) const
1098{
1099 wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
1100
1101 // An item is only visible if it's not a descendant of a collapsed item
1102 wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
1103 wxGenericTreeItem* parent = pItem->GetParent();
1104 while (parent)
1105 {
1106 if (!parent->IsExpanded())
1107 return false;
1108 parent = parent->GetParent();
1109 }
1110
1111 int startX, startY;
1112 GetViewStart(& startX, & startY);
1113
1114 wxSize clientSize = GetClientSize();
1115
1116 wxRect rect;
1117 if (!GetBoundingRect(item, rect))
1118 return false;
1119 if (rect.GetWidth() == 0 || rect.GetHeight() == 0)
1120 return false;
1121 if (rect.GetBottom() < 0 || rect.GetTop() > clientSize.y)
1122 return false;
1123 if (rect.GetRight() < 0 || rect.GetLeft() > clientSize.x)
1124 return false;
1125
1126 return true;
1127}
1128
1129bool wxGenericTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const
1130{
1131 wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
1132
1133 // consider that the item does have children if it has the "+" button: it
1134 // might not have them (if it had never been expanded yet) but then it
1135 // could have them as well and it's better to err on this side rather than
1136 // disabling some operations which are restricted to the items with
1137 // children for an item which does have them
1138 return ((wxGenericTreeItem*) item.m_pItem)->HasPlus();
1139}
1140
1141bool wxGenericTreeCtrl::IsExpanded(const wxTreeItemId& item) const
1142{
1143 wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
1144
1145 return ((wxGenericTreeItem*) item.m_pItem)->IsExpanded();
1146}
1147
1148bool wxGenericTreeCtrl::IsSelected(const wxTreeItemId& item) const
1149{
1150 wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
1151
1152 return ((wxGenericTreeItem*) item.m_pItem)->IsSelected();
1153}
1154
1155bool wxGenericTreeCtrl::IsBold(const wxTreeItemId& item) const
1156{
1157 wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
1158
1159 return ((wxGenericTreeItem*) item.m_pItem)->IsBold();
1160}
1161
1162// -----------------------------------------------------------------------------
1163// navigation
1164// -----------------------------------------------------------------------------
1165
1166wxTreeItemId wxGenericTreeCtrl::GetItemParent(const wxTreeItemId& item) const
1167{
1168 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1169
1170 return ((wxGenericTreeItem*) item.m_pItem)->GetParent();
1171}
1172
1173wxTreeItemId wxGenericTreeCtrl::GetFirstChild(const wxTreeItemId& item,
1174 wxTreeItemIdValue& cookie) const
1175{
1176 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1177
1178 cookie = 0;
1179 return GetNextChild(item, cookie);
1180}
1181
1182wxTreeItemId wxGenericTreeCtrl::GetNextChild(const wxTreeItemId& item,
1183 wxTreeItemIdValue& cookie) const
1184{
1185 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1186
1187 wxArrayGenericTreeItems& children = ((wxGenericTreeItem*) item.m_pItem)->GetChildren();
1188
1189 // it's ok to cast cookie to size_t, we never have indices big enough to
1190 // overflow "void *"
1191 size_t *pIndex = (size_t *)&cookie;
1192 if ( *pIndex < children.Count() )
1193 {
1194 return children.Item((*pIndex)++);
1195 }
1196 else
1197 {
1198 // there are no more of them
1199 return wxTreeItemId();
1200 }
1201}
1202
1203#if WXWIN_COMPATIBILITY_2_4
1204
1205wxTreeItemId wxGenericTreeCtrl::GetFirstChild(const wxTreeItemId& item,
1206 long& cookie) const
1207{
1208 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1209
1210 cookie = 0;
1211 return GetNextChild(item, cookie);
1212}
1213
1214wxTreeItemId wxGenericTreeCtrl::GetNextChild(const wxTreeItemId& item,
1215 long& cookie) const
1216{
1217 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1218
1219 wxArrayGenericTreeItems& children = ((wxGenericTreeItem*) item.m_pItem)->GetChildren();
1220 if ( (size_t)cookie < children.Count() )
1221 {
1222 return children.Item((size_t)cookie++);
1223 }
1224 else
1225 {
1226 // there are no more of them
1227 return wxTreeItemId();
1228 }
1229}
1230
1231#endif // WXWIN_COMPATIBILITY_2_4
1232
1233wxTreeItemId wxGenericTreeCtrl::GetLastChild(const wxTreeItemId& item) const
1234{
1235 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1236
1237 wxArrayGenericTreeItems& children = ((wxGenericTreeItem*) item.m_pItem)->GetChildren();
1238 return (children.IsEmpty() ? wxTreeItemId() : wxTreeItemId(children.Last()));
1239}
1240
1241wxTreeItemId wxGenericTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
1242{
1243 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1244
1245 wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
1246 wxGenericTreeItem *parent = i->GetParent();
1247 if ( parent == NULL )
1248 {
1249 // root item doesn't have any siblings
1250 return wxTreeItemId();
1251 }
1252
1253 wxArrayGenericTreeItems& siblings = parent->GetChildren();
1254 int index = siblings.Index(i);
1255 wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
1256
1257 size_t n = (size_t)(index + 1);
1258 return n == siblings.Count() ? wxTreeItemId() : wxTreeItemId(siblings[n]);
1259}
1260
1261wxTreeItemId wxGenericTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const
1262{
1263 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1264
1265 wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
1266 wxGenericTreeItem *parent = i->GetParent();
1267 if ( parent == NULL )
1268 {
1269 // root item doesn't have any siblings
1270 return wxTreeItemId();
1271 }
1272
1273 wxArrayGenericTreeItems& siblings = parent->GetChildren();
1274 int index = siblings.Index(i);
1275 wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
1276
1277 return index == 0 ? wxTreeItemId()
1278 : wxTreeItemId(siblings[(size_t)(index - 1)]);
1279}
1280
1281// Only for internal use right now, but should probably be public
1282wxTreeItemId wxGenericTreeCtrl::GetNext(const wxTreeItemId& item) const
1283{
1284 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1285
1286 wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
1287
1288 // First see if there are any children.
1289 wxArrayGenericTreeItems& children = i->GetChildren();
1290 if (children.GetCount() > 0)
1291 {
1292 return children.Item(0);
1293 }
1294 else
1295 {
1296 // Try a sibling of this or ancestor instead
1297 wxTreeItemId p = item;
1298 wxTreeItemId toFind;
1299 do
1300 {
1301 toFind = GetNextSibling(p);
1302 p = GetItemParent(p);
1303 } while (p.IsOk() && !toFind.IsOk());
1304 return toFind;
1305 }
1306}
1307
1308wxTreeItemId wxGenericTreeCtrl::GetFirstVisibleItem() const
1309{
1310 wxTreeItemId id = GetRootItem();
1311 if (!id.IsOk())
1312 return id;
1313
1314 do
1315 {
1316 if (IsVisible(id))
1317 return id;
1318 id = GetNext(id);
1319 } while (id.IsOk());
1320
1321 return wxTreeItemId();
1322}
1323
1324wxTreeItemId wxGenericTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
1325{
1326 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1327
1328 wxTreeItemId id = item;
1329 if (id.IsOk())
1330 {
1331 while (id = GetNext(id), id.IsOk())
1332 {
1333 if (IsVisible(id))
1334 return id;
1335 }
1336 }
1337 return wxTreeItemId();
1338}
1339
1340wxTreeItemId wxGenericTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
1341{
1342 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1343
1344 wxFAIL_MSG(wxT("not implemented"));
1345
1346 return wxTreeItemId();
1347}
1348
1349// called by wxTextTreeCtrl when it marks itself for deletion
1350void wxGenericTreeCtrl::ResetTextControl()
1351{
1352 m_textCtrl = NULL;
1353}
1354
1355// find the first item starting with the given prefix after the given item
1356wxTreeItemId wxGenericTreeCtrl::FindItem(const wxTreeItemId& idParent,
1357 const wxString& prefixOrig) const
1358{
1359 // match is case insensitive as this is more convenient to the user: having
1360 // to press Shift-letter to go to the item starting with a capital letter
1361 // would be too bothersome
1362 wxString prefix = prefixOrig.Lower();
1363
1364 // determine the starting point: we shouldn't take the current item (this
1365 // allows to switch between two items starting with the same letter just by
1366 // pressing it) but we shouldn't jump to the next one if the user is
1367 // continuing to type as otherwise he might easily skip the item he wanted
1368 wxTreeItemId id = idParent;
1369 if ( prefix.length() == 1 )
1370 {
1371 id = GetNext(id);
1372 }
1373
1374 // look for the item starting with the given prefix after it
1375 while ( id.IsOk() && !GetItemText(id).Lower().StartsWith(prefix) )
1376 {
1377 id = GetNext(id);
1378 }
1379
1380 // if we haven't found anything...
1381 if ( !id.IsOk() )
1382 {
1383 // ... wrap to the beginning
1384 id = GetRootItem();
1385 if ( HasFlag(wxTR_HIDE_ROOT) )
1386 {
1387 // can't select virtual root
1388 id = GetNext(id);
1389 }
1390
1391 // and try all the items (stop when we get to the one we started from)
1392 while ( id != idParent && !GetItemText(id).Lower().StartsWith(prefix) )
1393 {
1394 id = GetNext(id);
1395 }
1396 }
1397
1398 return id;
1399}
1400
1401// -----------------------------------------------------------------------------
1402// operations
1403// -----------------------------------------------------------------------------
1404
1405wxTreeItemId wxGenericTreeCtrl::DoInsertItem(const wxTreeItemId& parentId,
1406 size_t previous,
1407 const wxString& text,
1408 int image,
1409 int selImage,
1410 wxTreeItemData *data)
1411{
1412 wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem;
1413 if ( !parent )
1414 {
1415 // should we give a warning here?
1416 return AddRoot(text, image, selImage, data);
1417 }
1418
1419 m_dirty = true; // do this first so stuff below doesn't cause flicker
1420
1421 wxGenericTreeItem *item =
1422 new wxGenericTreeItem( parent, text, image, selImage, data );
1423
1424 if ( data != NULL )
1425 {
1426 data->m_pItem = item;
1427 }
1428
1429 parent->Insert( item, previous == (size_t)-1 ? parent->GetChildren().size()
1430 : previous );
1431
1432 return item;
1433}
1434
1435wxTreeItemId wxGenericTreeCtrl::AddRoot(const wxString& text,
1436 int image,
1437 int selImage,
1438 wxTreeItemData *data)
1439{
1440 wxCHECK_MSG( !m_anchor, wxTreeItemId(), wxT("tree can have only one root") );
1441
1442 m_dirty = true; // do this first so stuff below doesn't cause flicker
1443
1444 m_anchor = new wxGenericTreeItem((wxGenericTreeItem *)NULL, text,
1445 image, selImage, data);
1446 if ( data != NULL )
1447 {
1448 data->m_pItem = m_anchor;
1449 }
1450
1451 if (HasFlag(wxTR_HIDE_ROOT))
1452 {
1453 // if root is hidden, make sure we can navigate
1454 // into children
1455 m_anchor->SetHasPlus();
1456 m_anchor->Expand();
1457 CalculatePositions();
1458 }
1459
1460 if (!HasFlag(wxTR_MULTIPLE))
1461 {
1462 m_current = m_key_current = m_anchor;
1463 m_current->SetHilight( true );
1464 }
1465
1466 return m_anchor;
1467}
1468
1469wxTreeItemId wxGenericTreeCtrl::DoInsertAfter(const wxTreeItemId& parentId,
1470 const wxTreeItemId& idPrevious,
1471 const wxString& text,
1472 int image, int selImage,
1473 wxTreeItemData *data)
1474{
1475 wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem;
1476 if ( !parent )
1477 {
1478 // should we give a warning here?
1479 return AddRoot(text, image, selImage, data);
1480 }
1481
1482 int index = -1;
1483 if (idPrevious.IsOk())
1484 {
1485 index = parent->GetChildren().Index((wxGenericTreeItem*) idPrevious.m_pItem);
1486 wxASSERT_MSG( index != wxNOT_FOUND,
1487 wxT("previous item in wxGenericTreeCtrl::InsertItem() is not a sibling") );
1488 }
1489
1490 return DoInsertItem(parentId, (size_t)++index, text, image, selImage, data);
1491}
1492
1493
1494void wxGenericTreeCtrl::SendDeleteEvent(wxGenericTreeItem *item)
1495{
1496 wxTreeEvent event( wxEVT_COMMAND_TREE_DELETE_ITEM, GetId() );
1497 event.m_item = item;
1498 event.SetEventObject( this );
1499 ProcessEvent( event );
1500}
1501
1502// Don't leave edit or selection on a child which is about to disappear
1503void wxGenericTreeCtrl::ChildrenClosing(wxGenericTreeItem* item)
1504{
1505 if (m_textCtrl != NULL && item != m_textCtrl->item() && IsDescendantOf(item, m_textCtrl->item())) {
1506 m_textCtrl->StopEditing();
1507 }
1508 if (item != m_key_current && IsDescendantOf(item, m_key_current)) {
1509 m_key_current = NULL;
1510 }
1511 if (IsDescendantOf(item, m_select_me)) {
1512 m_select_me = item;
1513 }
1514 if (item != m_current && IsDescendantOf(item, m_current)) {
1515 m_current->SetHilight( false );
1516 m_current = NULL;
1517 m_select_me = item;
1518 }
1519}
1520
1521void wxGenericTreeCtrl::DeleteChildren(const wxTreeItemId& itemId)
1522{
1523 m_dirty = true; // do this first so stuff below doesn't cause flicker
1524
1525 wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1526 ChildrenClosing(item);
1527 item->DeleteChildren(this);
1528}
1529
1530void wxGenericTreeCtrl::Delete(const wxTreeItemId& itemId)
1531{
1532 m_dirty = true; // do this first so stuff below doesn't cause flicker
1533
1534 wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1535
1536 if (m_textCtrl != NULL && IsDescendantOf(item, m_textCtrl->item()))
1537 {
1538 // can't delete the item being edited, cancel editing it first
1539 m_textCtrl->StopEditing();
1540 }
1541
1542 wxGenericTreeItem *parent = item->GetParent();
1543
1544 // don't keep stale pointers around!
1545 if ( IsDescendantOf(item, m_key_current) )
1546 {
1547 // Don't silently change the selection:
1548 // do it properly in idle time, so event
1549 // handlers get called.
1550
1551 // m_key_current = parent;
1552 m_key_current = NULL;
1553 }
1554
1555 // m_select_me records whether we need to select
1556 // a different item, in idle time.
1557 if ( m_select_me && IsDescendantOf(item, m_select_me) )
1558 {
1559 m_select_me = parent;
1560 }
1561
1562 if ( IsDescendantOf(item, m_current) )
1563 {
1564 // Don't silently change the selection:
1565 // do it properly in idle time, so event
1566 // handlers get called.
1567
1568 // m_current = parent;
1569 m_current = NULL;
1570 m_select_me = parent;
1571 }
1572
1573 // remove the item from the tree
1574 if ( parent )
1575 {
1576 parent->GetChildren().Remove( item ); // remove by value
1577 }
1578 else // deleting the root
1579 {
1580 // nothing will be left in the tree
1581 m_anchor = NULL;
1582 }
1583
1584 // and delete all of its children and the item itself now
1585 item->DeleteChildren(this);
1586 SendDeleteEvent(item);
1587
1588 if (item == m_select_me)
1589 m_select_me = NULL;
1590
1591 delete item;
1592}
1593
1594void wxGenericTreeCtrl::DeleteAllItems()
1595{
1596 if ( m_anchor )
1597 {
1598 Delete(m_anchor);
1599 }
1600}
1601
1602void wxGenericTreeCtrl::Expand(const wxTreeItemId& itemId)
1603{
1604 wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1605
1606 wxCHECK_RET( item, _T("invalid item in wxGenericTreeCtrl::Expand") );
1607 wxCHECK_RET( !HasFlag(wxTR_HIDE_ROOT) || itemId != GetRootItem(),
1608 _T("can't expand hidden root") );
1609
1610 if ( !item->HasPlus() )
1611 return;
1612
1613 if ( item->IsExpanded() )
1614 return;
1615
1616 wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_EXPANDING, GetId() );
1617 event.m_item = item;
1618 event.SetEventObject( this );
1619
1620 if ( ProcessEvent( event ) && !event.IsAllowed() )
1621 {
1622 // cancelled by program
1623 return;
1624 }
1625
1626 item->Expand();
1627 CalculatePositions();
1628
1629 RefreshSubtree(item);
1630
1631 event.SetEventType(wxEVT_COMMAND_TREE_ITEM_EXPANDED);
1632 ProcessEvent( event );
1633}
1634
1635void wxGenericTreeCtrl::ExpandAll(const wxTreeItemId& item)
1636{
1637 if ( !HasFlag(wxTR_HIDE_ROOT) || item != GetRootItem())
1638 {
1639 Expand(item);
1640 if ( !IsExpanded(item) )
1641 return;
1642 }
1643
1644 wxTreeItemIdValue cookie;
1645 wxTreeItemId child = GetFirstChild(item, cookie);
1646 while ( child.IsOk() )
1647 {
1648 ExpandAll(child);
1649
1650 child = GetNextChild(item, cookie);
1651 }
1652}
1653
1654void wxGenericTreeCtrl::Collapse(const wxTreeItemId& itemId)
1655{
1656 wxCHECK_RET( !HasFlag(wxTR_HIDE_ROOT) || itemId != GetRootItem(),
1657 _T("can't collapse hidden root") );
1658
1659 wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1660
1661 if ( !item->IsExpanded() )
1662 return;
1663
1664 wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_COLLAPSING, GetId() );
1665 event.m_item = item;
1666 event.SetEventObject( this );
1667 if ( ProcessEvent( event ) && !event.IsAllowed() )
1668 {
1669 // cancelled by program
1670 return;
1671 }
1672
1673 ChildrenClosing(item);
1674 item->Collapse();
1675
1676#if 0 // TODO why should items be collapsed recursively?
1677 wxArrayGenericTreeItems& children = item->GetChildren();
1678 size_t count = children.Count();
1679 for ( size_t n = 0; n < count; n++ )
1680 {
1681 Collapse(children[n]);
1682 }
1683#endif
1684
1685 CalculatePositions();
1686
1687 RefreshSubtree(item);
1688
1689 event.SetEventType(wxEVT_COMMAND_TREE_ITEM_COLLAPSED);
1690 ProcessEvent( event );
1691}
1692
1693void wxGenericTreeCtrl::CollapseAndReset(const wxTreeItemId& item)
1694{
1695 Collapse(item);
1696 DeleteChildren(item);
1697}
1698
1699void wxGenericTreeCtrl::Toggle(const wxTreeItemId& itemId)
1700{
1701 wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1702
1703 if (item->IsExpanded())
1704 Collapse(itemId);
1705 else
1706 Expand(itemId);
1707}
1708
1709void wxGenericTreeCtrl::Unselect()
1710{
1711 if (m_current)
1712 {
1713 m_current->SetHilight( false );
1714 RefreshLine( m_current );
1715
1716 m_current = NULL;
1717 m_select_me = NULL;
1718 }
1719}
1720
1721void wxGenericTreeCtrl::UnselectAllChildren(wxGenericTreeItem *item)
1722{
1723 if (item->IsSelected())
1724 {
1725 item->SetHilight(false);
1726 RefreshLine(item);
1727 }
1728
1729 if (item->HasChildren())
1730 {
1731 wxArrayGenericTreeItems& children = item->GetChildren();
1732 size_t count = children.Count();
1733 for ( size_t n = 0; n < count; ++n )
1734 {
1735 UnselectAllChildren(children[n]);
1736 }
1737 }
1738}
1739
1740void wxGenericTreeCtrl::UnselectAll()
1741{
1742 wxTreeItemId rootItem = GetRootItem();
1743
1744 // the tree might not have the root item at all
1745 if ( rootItem )
1746 {
1747 UnselectAllChildren((wxGenericTreeItem*) rootItem.m_pItem);
1748 }
1749}
1750
1751// Recursive function !
1752// To stop we must have crt_item<last_item
1753// Algorithm :
1754// Tag all next children, when no more children,
1755// Move to parent (not to tag)
1756// Keep going... if we found last_item, we stop.
1757bool wxGenericTreeCtrl::TagNextChildren(wxGenericTreeItem *crt_item, wxGenericTreeItem *last_item, bool select)
1758{
1759 wxGenericTreeItem *parent = crt_item->GetParent();
1760
1761 if (parent == NULL) // This is root item
1762 return TagAllChildrenUntilLast(crt_item, last_item, select);
1763
1764 wxArrayGenericTreeItems& children = parent->GetChildren();
1765 int index = children.Index(crt_item);
1766 wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
1767
1768 size_t count = children.Count();
1769 for (size_t n=(size_t)(index+1); n<count; ++n)
1770 {
1771 if (TagAllChildrenUntilLast(children[n], last_item, select)) return true;
1772 }
1773
1774 return TagNextChildren(parent, last_item, select);
1775}
1776
1777bool wxGenericTreeCtrl::TagAllChildrenUntilLast(wxGenericTreeItem *crt_item, wxGenericTreeItem *last_item, bool select)
1778{
1779 crt_item->SetHilight(select);
1780 RefreshLine(crt_item);
1781
1782 if (crt_item==last_item)
1783 return true;
1784
1785 if (crt_item->HasChildren())
1786 {
1787 wxArrayGenericTreeItems& children = crt_item->GetChildren();
1788 size_t count = children.Count();
1789 for ( size_t n = 0; n < count; ++n )
1790 {
1791 if (TagAllChildrenUntilLast(children[n], last_item, select))
1792 return true;
1793 }
1794 }
1795
1796 return false;
1797}
1798
1799void wxGenericTreeCtrl::SelectItemRange(wxGenericTreeItem *item1, wxGenericTreeItem *item2)
1800{
1801 m_select_me = NULL;
1802
1803 // item2 is not necessary after item1
1804 // choice first' and 'last' between item1 and item2
1805 wxGenericTreeItem *first= (item1->GetY()<item2->GetY()) ? item1 : item2;
1806 wxGenericTreeItem *last = (item1->GetY()<item2->GetY()) ? item2 : item1;
1807
1808 bool select = m_current->IsSelected();
1809
1810 if ( TagAllChildrenUntilLast(first,last,select) )
1811 return;
1812
1813 TagNextChildren(first,last,select);
1814}
1815
1816void wxGenericTreeCtrl::DoSelectItem(const wxTreeItemId& itemId,
1817 bool unselect_others,
1818 bool extended_select)
1819{
1820 wxCHECK_RET( itemId.IsOk(), wxT("invalid tree item") );
1821
1822 m_select_me = NULL;
1823
1824 bool is_single=!(GetWindowStyleFlag() & wxTR_MULTIPLE);
1825 wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1826
1827 //wxCHECK_RET( ( (!unselect_others) && is_single),
1828 // wxT("this is a single selection tree") );
1829
1830 // to keep going anyhow !!!
1831 if (is_single)
1832 {
1833 if (item->IsSelected())
1834 return; // nothing to do
1835 unselect_others = true;
1836 extended_select = false;
1837 }
1838 else if ( unselect_others && item->IsSelected() )
1839 {
1840 // selection change if there is more than one item currently selected
1841 wxArrayTreeItemIds selected_items;
1842 if ( GetSelections(selected_items) == 1 )
1843 return;
1844 }
1845
1846 wxTreeEvent event( wxEVT_COMMAND_TREE_SEL_CHANGING, GetId() );
1847 event.m_item = item;
1848 event.m_itemOld = m_current;
1849 event.SetEventObject( this );
1850 // TODO : Here we don't send any selection mode yet !
1851
1852 if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() )
1853 return;
1854
1855 wxTreeItemId parent = GetItemParent( itemId );
1856 while (parent.IsOk())
1857 {
1858 if (!IsExpanded(parent))
1859 Expand( parent );
1860
1861 parent = GetItemParent( parent );
1862 }
1863
1864 // ctrl press
1865 if (unselect_others)
1866 {
1867 if (is_single) Unselect(); // to speed up thing
1868 else UnselectAll();
1869 }
1870
1871 // shift press
1872 if (extended_select)
1873 {
1874 if ( !m_current )
1875 {
1876 m_current = m_key_current = (wxGenericTreeItem*) GetRootItem().m_pItem;
1877 }
1878
1879 // don't change the mark (m_current)
1880 SelectItemRange(m_current, item);
1881 }
1882 else
1883 {
1884 bool select = true; // the default
1885
1886 // Check if we need to toggle hilight (ctrl mode)
1887 if (!unselect_others)
1888 select=!item->IsSelected();
1889
1890 m_current = m_key_current = item;
1891 m_current->SetHilight(select);
1892 RefreshLine( m_current );
1893 }
1894
1895 // This can cause idle processing to select the root
1896 // if no item is selected, so it must be after the
1897 // selection is set
1898 EnsureVisible( itemId );
1899
1900 event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
1901 GetEventHandler()->ProcessEvent( event );
1902}
1903
1904void wxGenericTreeCtrl::SelectItem(const wxTreeItemId& itemId, bool select)
1905{
1906 if ( select )
1907 {
1908 DoSelectItem(itemId, !HasFlag(wxTR_MULTIPLE));
1909 }
1910 else // deselect
1911 {
1912 wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1913 wxCHECK_RET( item, wxT("SelectItem(): invalid tree item") );
1914
1915 item->SetHilight(false);
1916 RefreshLine(item);
1917 }
1918}
1919
1920void wxGenericTreeCtrl::FillArray(wxGenericTreeItem *item,
1921 wxArrayTreeItemIds &array) const
1922{
1923 if ( item->IsSelected() )
1924 array.Add(wxTreeItemId(item));
1925
1926 if ( item->HasChildren() )
1927 {
1928 wxArrayGenericTreeItems& children = item->GetChildren();
1929 size_t count = children.GetCount();
1930 for ( size_t n = 0; n < count; ++n )
1931 FillArray(children[n], array);
1932 }
1933}
1934
1935size_t wxGenericTreeCtrl::GetSelections(wxArrayTreeItemIds &array) const
1936{
1937 array.Empty();
1938 wxTreeItemId idRoot = GetRootItem();
1939 if ( idRoot.IsOk() )
1940 {
1941 FillArray((wxGenericTreeItem*) idRoot.m_pItem, array);
1942 }
1943 //else: the tree is empty, so no selections
1944
1945 return array.Count();
1946}
1947
1948void wxGenericTreeCtrl::EnsureVisible(const wxTreeItemId& item)
1949{
1950 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1951
1952 if (!item.IsOk()) return;
1953
1954 wxGenericTreeItem *gitem = (wxGenericTreeItem*) item.m_pItem;
1955
1956 // first expand all parent branches
1957 wxGenericTreeItem *parent = gitem->GetParent();
1958
1959 if ( HasFlag(wxTR_HIDE_ROOT) )
1960 {
1961 while ( parent && parent != m_anchor )
1962 {
1963 Expand(parent);
1964 parent = parent->GetParent();
1965 }
1966 }
1967 else
1968 {
1969 while ( parent )
1970 {
1971 Expand(parent);
1972 parent = parent->GetParent();
1973 }
1974 }
1975
1976 //if (parent) CalculatePositions();
1977
1978 ScrollTo(item);
1979}
1980
1981void wxGenericTreeCtrl::ScrollTo(const wxTreeItemId &item)
1982{
1983 if (!item.IsOk()) return;
1984
1985 // We have to call this here because the label in
1986 // question might just have been added and no screen
1987 // update taken place.
1988 if (m_dirty)
1989#if defined( __WXMSW__ ) || defined(__WXMAC__)
1990 Update();
1991#else
1992 wxYieldIfNeeded();
1993#endif
1994 wxGenericTreeItem *gitem = (wxGenericTreeItem*) item.m_pItem;
1995
1996 // now scroll to the item
1997 int item_y = gitem->GetY();
1998
1999 int start_x = 0;
2000 int start_y = 0;
2001 GetViewStart( &start_x, &start_y );
2002 start_y *= PIXELS_PER_UNIT;
2003
2004 int client_h = 0;
2005 int client_w = 0;
2006 GetClientSize( &client_w, &client_h );
2007
2008 if (item_y < start_y+3)
2009 {
2010 // going down
2011 int x = 0;
2012 int y = 0;
2013 m_anchor->GetSize( x, y, this );
2014 y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
2015 x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
2016 int x_pos = GetScrollPos( wxHORIZONTAL );
2017 // Item should appear at top
2018 SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, item_y/PIXELS_PER_UNIT );
2019 }
2020 else if (item_y+GetLineHeight(gitem) > start_y+client_h)
2021 {
2022 // going up
2023 int x = 0;
2024 int y = 0;
2025 m_anchor->GetSize( x, y, this );
2026 y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
2027 x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
2028 item_y += PIXELS_PER_UNIT+2;
2029 int x_pos = GetScrollPos( wxHORIZONTAL );
2030 // Item should appear at bottom
2031 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 );
2032 }
2033}
2034
2035// FIXME: tree sorting functions are not reentrant and not MT-safe!
2036static wxGenericTreeCtrl *s_treeBeingSorted = NULL;
2037
2038static int LINKAGEMODE tree_ctrl_compare_func(wxGenericTreeItem **item1,
2039 wxGenericTreeItem **item2)
2040{
2041 wxCHECK_MSG( s_treeBeingSorted, 0, wxT("bug in wxGenericTreeCtrl::SortChildren()") );
2042
2043 return s_treeBeingSorted->OnCompareItems(*item1, *item2);
2044}
2045
2046void wxGenericTreeCtrl::SortChildren(const wxTreeItemId& itemId)
2047{
2048 wxCHECK_RET( itemId.IsOk(), wxT("invalid tree item") );
2049
2050 wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
2051
2052 wxCHECK_RET( !s_treeBeingSorted,
2053 wxT("wxGenericTreeCtrl::SortChildren is not reentrant") );
2054
2055 wxArrayGenericTreeItems& children = item->GetChildren();
2056 if ( children.Count() > 1 )
2057 {
2058 m_dirty = true;
2059
2060 s_treeBeingSorted = this;
2061 children.Sort(tree_ctrl_compare_func);
2062 s_treeBeingSorted = NULL;
2063 }
2064 //else: don't make the tree dirty as nothing changed
2065}
2066
2067void wxGenericTreeCtrl::CalculateLineHeight()
2068{
2069 wxClientDC dc(this);
2070 m_lineHeight = (int)(dc.GetCharHeight() + 4);
2071
2072 if ( m_imageListNormal )
2073 {
2074 // Calculate a m_lineHeight value from the normal Image sizes.
2075 // May be toggle off. Then wxGenericTreeCtrl will spread when
2076 // necessary (which might look ugly).
2077 int n = m_imageListNormal->GetImageCount();
2078 for (int i = 0; i < n ; i++)
2079 {
2080 int width = 0, height = 0;
2081 m_imageListNormal->GetSize(i, width, height);
2082 if (height > m_lineHeight) m_lineHeight = height;
2083 }
2084 }
2085
2086 if (m_imageListButtons)
2087 {
2088 // Calculate a m_lineHeight value from the Button image sizes.
2089 // May be toggle off. Then wxGenericTreeCtrl will spread when
2090 // necessary (which might look ugly).
2091 int n = m_imageListButtons->GetImageCount();
2092 for (int i = 0; i < n ; i++)
2093 {
2094 int width = 0, height = 0;
2095 m_imageListButtons->GetSize(i, width, height);
2096 if (height > m_lineHeight) m_lineHeight = height;
2097 }
2098 }
2099
2100 if (m_lineHeight < 30)
2101 m_lineHeight += 2; // at least 2 pixels
2102 else
2103 m_lineHeight += m_lineHeight/10; // otherwise 10% extra spacing
2104}
2105
2106void wxGenericTreeCtrl::SetImageList(wxImageList *imageList)
2107{
2108 if (m_ownsImageListNormal) delete m_imageListNormal;
2109 m_imageListNormal = imageList;
2110 m_ownsImageListNormal = false;
2111 m_dirty = true;
2112 // Don't do any drawing if we're setting the list to NULL,
2113 // since we may be in the process of deleting the tree control.
2114 if (imageList)
2115 CalculateLineHeight();
2116}
2117
2118void wxGenericTreeCtrl::SetStateImageList(wxImageList *imageList)
2119{
2120 if (m_ownsImageListState) delete m_imageListState;
2121 m_imageListState = imageList;
2122 m_ownsImageListState = false;
2123}
2124
2125void wxGenericTreeCtrl::SetButtonsImageList(wxImageList *imageList)
2126{
2127 if (m_ownsImageListButtons) delete m_imageListButtons;
2128 m_imageListButtons = imageList;
2129 m_ownsImageListButtons = false;
2130 m_dirty = true;
2131 CalculateLineHeight();
2132}
2133
2134void wxGenericTreeCtrl::AssignButtonsImageList(wxImageList *imageList)
2135{
2136 SetButtonsImageList(imageList);
2137 m_ownsImageListButtons = true;
2138}
2139
2140// -----------------------------------------------------------------------------
2141// helpers
2142// -----------------------------------------------------------------------------
2143
2144void wxGenericTreeCtrl::AdjustMyScrollbars()
2145{
2146 if (m_anchor)
2147 {
2148 int x = 0, y = 0;
2149 m_anchor->GetSize( x, y, this );
2150 y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
2151 x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
2152 int x_pos = GetScrollPos( wxHORIZONTAL );
2153 int y_pos = GetScrollPos( wxVERTICAL );
2154 SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, y_pos );
2155 }
2156 else
2157 {
2158 SetScrollbars( 0, 0, 0, 0 );
2159 }
2160}
2161
2162int wxGenericTreeCtrl::GetLineHeight(wxGenericTreeItem *item) const
2163{
2164 if (GetWindowStyleFlag() & wxTR_HAS_VARIABLE_ROW_HEIGHT)
2165 return item->GetHeight();
2166 else
2167 return m_lineHeight;
2168}
2169
2170void wxGenericTreeCtrl::PaintItem(wxGenericTreeItem *item, wxDC& dc)
2171{
2172 // TODO implement "state" icon on items
2173
2174 wxTreeItemAttr *attr = item->GetAttributes();
2175 if ( attr && attr->HasFont() )
2176 dc.SetFont(attr->GetFont());
2177 else if (item->IsBold())
2178 dc.SetFont(m_boldFont);
2179
2180 long text_w = 0, text_h = 0;
2181 dc.GetTextExtent( item->GetText(), &text_w, &text_h );
2182
2183 int image_h = 0, image_w = 0;
2184 int image = item->GetCurrentImage();
2185 if ( image != NO_IMAGE )
2186 {
2187 if ( m_imageListNormal )
2188 {
2189 m_imageListNormal->GetSize( image, image_w, image_h );
2190 image_w += MARGIN_BETWEEN_IMAGE_AND_TEXT;
2191 }
2192 else
2193 {
2194 image = NO_IMAGE;
2195 }
2196 }
2197
2198 int total_h = GetLineHeight(item);
2199 bool drawItemBackground = false;
2200
2201 if ( item->IsSelected() )
2202 {
2203// under mac selections are only a rectangle in case they don't have the focus
2204#ifdef __WXMAC__
2205 if ( !m_hasFocus )
2206 {
2207 dc.SetBrush( *wxTRANSPARENT_BRUSH ) ;
2208 dc.SetPen( wxPen( wxSystemSettings::GetColour( wxSYS_COLOUR_HIGHLIGHT ) , 1 , wxSOLID ) ) ;
2209 }
2210 else
2211 {
2212 dc.SetBrush( *m_hilightBrush ) ;
2213 }
2214#else
2215 dc.SetBrush(*(m_hasFocus ? m_hilightBrush : m_hilightUnfocusedBrush));
2216#endif
2217 drawItemBackground = true;
2218 }
2219 else
2220 {
2221 wxColour colBg;
2222 if ( attr && attr->HasBackgroundColour() )
2223 {
2224 drawItemBackground = true;
2225 colBg = attr->GetBackgroundColour();
2226 }
2227 else
2228 {
2229 colBg = GetBackgroundColour();
2230 }
2231 dc.SetBrush(wxBrush(colBg, wxSOLID));
2232 }
2233
2234 int offset = HasFlag(wxTR_ROW_LINES) ? 1 : 0;
2235
2236 if ( HasFlag(wxTR_FULL_ROW_HIGHLIGHT) )
2237 {
2238 int x, y, w, h;
2239
2240 DoGetPosition(&x, &y);
2241 DoGetSize(&w, &h);
2242 dc.DrawRectangle(x, item->GetY()+offset, w, total_h-offset);
2243 }
2244 else
2245 {
2246 if ( item->IsSelected() && image != NO_IMAGE )
2247 {
2248 // If it's selected, and there's an image, then we should
2249 // take care to leave the area under the image painted in the
2250 // background colour.
2251 dc.DrawRectangle( item->GetX() + image_w - 2, item->GetY()+offset,
2252 item->GetWidth() - image_w + 2, total_h-offset );
2253 }
2254 // On GTK+ 2, drawing a 'normal' background is wrong for themes that
2255 // don't allow backgrounds to be customized. Not drawing the background,
2256 // except for custom item backgrounds, works for both kinds of theme.
2257 else if (drawItemBackground)
2258 {
2259 dc.DrawRectangle( item->GetX()-2, item->GetY()+offset,
2260 item->GetWidth()+2, total_h-offset );
2261 }
2262 }
2263
2264 if ( image != NO_IMAGE )
2265 {
2266 dc.SetClippingRegion( item->GetX(), item->GetY(), image_w-2, total_h );
2267 m_imageListNormal->Draw( image, dc,
2268 item->GetX(),
2269 item->GetY() +((total_h > image_h)?((total_h-image_h)/2):0),
2270 wxIMAGELIST_DRAW_TRANSPARENT );
2271 dc.DestroyClippingRegion();
2272 }
2273
2274 dc.SetBackgroundMode(wxTRANSPARENT);
2275 int extraH = (total_h > text_h) ? (total_h - text_h)/2 : 0;
2276 dc.DrawText( item->GetText(),
2277 (wxCoord)(image_w + item->GetX()),
2278 (wxCoord)(item->GetY() + extraH));
2279
2280 // restore normal font
2281 dc.SetFont( m_normalFont );
2282}
2283
2284// Now y stands for the top of the item, whereas it used to stand for middle !
2285void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y )
2286{
2287 int x = level*m_indent;
2288 if (!HasFlag(wxTR_HIDE_ROOT))
2289 {
2290 x += m_indent;
2291 }
2292 else if (level == 0)
2293 {
2294 // always expand hidden root
2295 int origY = y;
2296 wxArrayGenericTreeItems& children = item->GetChildren();
2297 int count = children.Count();
2298 if (count > 0)
2299 {
2300 int n = 0, oldY;
2301 do {
2302 oldY = y;
2303 PaintLevel(children[n], dc, 1, y);
2304 } while (++n < count);
2305
2306 if (!HasFlag(wxTR_NO_LINES) && HasFlag(wxTR_LINES_AT_ROOT) && count > 0)
2307 {
2308 // draw line down to last child
2309 origY += GetLineHeight(children[0])>>1;
2310 oldY += GetLineHeight(children[n-1])>>1;
2311 dc.DrawLine(3, origY, 3, oldY);
2312 }
2313 }
2314 return;
2315 }
2316
2317 item->SetX(x+m_spacing);
2318 item->SetY(y);
2319
2320 int h = GetLineHeight(item);
2321 int y_top = y;
2322 int y_mid = y_top + (h>>1);
2323 y += h;
2324
2325 int exposed_x = dc.LogicalToDeviceX(0);
2326 int exposed_y = dc.LogicalToDeviceY(y_top);
2327
2328 if (IsExposed(exposed_x, exposed_y, 10000, h)) // 10000 = very much
2329 {
2330 const wxPen *pen =
2331#ifndef __WXMAC__
2332 // don't draw rect outline if we already have the
2333 // background color under Mac
2334 (item->IsSelected() && m_hasFocus) ? wxBLACK_PEN :
2335#endif // !__WXMAC__
2336 wxTRANSPARENT_PEN;
2337
2338 wxColour colText;
2339 if ( item->IsSelected()
2340#ifdef __WXMAC__
2341 // On wxMac, if the tree doesn't have the focus we draw an empty
2342 // rectangle, so we want to make sure that the text is visible
2343 // against the normal background, not the highlightbackground, so
2344 // don't use the highlight text colour unless we have the focus.
2345 && m_hasFocus
2346#endif
2347 )
2348 {
2349 colText = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
2350 }
2351 else
2352 {
2353 wxTreeItemAttr *attr = item->GetAttributes();
2354 if (attr && attr->HasTextColour())
2355 colText = attr->GetTextColour();
2356 else
2357 colText = GetForegroundColour();
2358 }
2359
2360 // prepare to draw
2361 dc.SetTextForeground(colText);
2362 dc.SetPen(*pen);
2363
2364 // draw
2365 PaintItem(item, dc);
2366
2367 if (HasFlag(wxTR_ROW_LINES))
2368 {
2369 // if the background colour is white, choose a
2370 // contrasting color for the lines
2371 dc.SetPen(*((GetBackgroundColour() == *wxWHITE)
2372 ? wxMEDIUM_GREY_PEN : wxWHITE_PEN));
2373 dc.DrawLine(0, y_top, 10000, y_top);
2374 dc.DrawLine(0, y, 10000, y);
2375 }
2376
2377 // restore DC objects
2378 dc.SetBrush(*wxWHITE_BRUSH);
2379 dc.SetPen(m_dottedPen);
2380 dc.SetTextForeground(*wxBLACK);
2381
2382 if ( !HasFlag(wxTR_NO_LINES) )
2383 {
2384 // draw the horizontal line here
2385 int x_start = x;
2386 if (x > (signed)m_indent)
2387 x_start -= m_indent;
2388 else if (HasFlag(wxTR_LINES_AT_ROOT))
2389 x_start = 3;
2390 dc.DrawLine(x_start, y_mid, x + m_spacing, y_mid);
2391 }
2392
2393 // should the item show a button?
2394 if ( item->HasPlus() && HasButtons() )
2395 {
2396 if ( m_imageListButtons )
2397 {
2398 // draw the image button here
2399 int image_h = 0,
2400 image_w = 0;
2401 int image = item->IsExpanded() ? wxTreeItemIcon_Expanded
2402 : wxTreeItemIcon_Normal;
2403 if ( item->IsSelected() )
2404 image += wxTreeItemIcon_Selected - wxTreeItemIcon_Normal;
2405
2406 m_imageListButtons->GetSize(image, image_w, image_h);
2407 int xx = x - image_w/2;
2408 int yy = y_mid - image_h/2;
2409
2410 wxDCClipper clip(dc, xx, yy, image_w, image_h);
2411 m_imageListButtons->Draw(image, dc, xx, yy,
2412 wxIMAGELIST_DRAW_TRANSPARENT);
2413 }
2414 else // no custom buttons
2415 {
2416 static const int wImage = 9;
2417 static const int hImage = 9;
2418
2419 int flag = 0;
2420 if (item->IsExpanded())
2421 flag |= wxCONTROL_EXPANDED;
2422 if (item == m_underMouse)
2423 flag |= wxCONTROL_CURRENT;
2424
2425 wxRendererNative::Get().DrawTreeItemButton
2426 (
2427 this,
2428 dc,
2429 wxRect(x - wImage/2,
2430 y_mid - hImage/2,
2431 wImage, hImage),
2432 flag
2433 );
2434 }
2435 }
2436 }
2437
2438 if (item->IsExpanded())
2439 {
2440 wxArrayGenericTreeItems& children = item->GetChildren();
2441 int count = children.Count();
2442 if (count > 0)
2443 {
2444 int n = 0, oldY;
2445 ++level;
2446 do {
2447 oldY = y;
2448 PaintLevel(children[n], dc, level, y);
2449 } while (++n < count);
2450
2451 if (!HasFlag(wxTR_NO_LINES) && count > 0)
2452 {
2453 // draw line down to last child
2454 oldY += GetLineHeight(children[n-1])>>1;
2455 if (HasButtons()) y_mid += 5;
2456
2457 // Only draw the portion of the line that is visible, in case it is huge
2458 wxCoord xOrigin=0, yOrigin=0, width, height;
2459 dc.GetDeviceOrigin(&xOrigin, &yOrigin);
2460 yOrigin = abs(yOrigin);
2461 GetClientSize(&width, &height);
2462
2463 // Move end points to the begining/end of the view?
2464 if (y_mid < yOrigin)
2465 y_mid = yOrigin;
2466 if (oldY > yOrigin + height)
2467 oldY = yOrigin + height;
2468
2469 // after the adjustments if y_mid is larger than oldY then the line
2470 // isn't visible at all so don't draw anything
2471 if (y_mid < oldY)
2472 dc.DrawLine(x, y_mid, x, oldY);
2473 }
2474 }
2475 }
2476}
2477
2478void wxGenericTreeCtrl::DrawDropEffect(wxGenericTreeItem *item)
2479{
2480 if ( item )
2481 {
2482 if ( item->HasPlus() )
2483 {
2484 // it's a folder, indicate it by a border
2485 DrawBorder(item);
2486 }
2487 else
2488 {
2489 // draw a line under the drop target because the item will be
2490 // dropped there
2491 DrawLine(item, !m_dropEffectAboveItem );
2492 }
2493
2494 SetCursor(wxCURSOR_BULLSEYE);
2495 }
2496 else
2497 {
2498 // can't drop here
2499 SetCursor(wxCURSOR_NO_ENTRY);
2500 }
2501}
2502
2503void wxGenericTreeCtrl::DrawBorder(const wxTreeItemId &item)
2504{
2505 wxCHECK_RET( item.IsOk(), _T("invalid item in wxGenericTreeCtrl::DrawLine") );
2506
2507 wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
2508
2509 wxClientDC dc(this);
2510 PrepareDC( dc );
2511 dc.SetLogicalFunction(wxINVERT);
2512 dc.SetBrush(*wxTRANSPARENT_BRUSH);
2513
2514 int w = i->GetWidth() + 2;
2515 int h = GetLineHeight(i) + 2;
2516
2517 dc.DrawRectangle( i->GetX() - 1, i->GetY() - 1, w, h);
2518}
2519
2520void wxGenericTreeCtrl::DrawLine(const wxTreeItemId &item, bool below)
2521{
2522 wxCHECK_RET( item.IsOk(), _T("invalid item in wxGenericTreeCtrl::DrawLine") );
2523
2524 wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
2525
2526 wxClientDC dc(this);
2527 PrepareDC( dc );
2528 dc.SetLogicalFunction(wxINVERT);
2529
2530 int x = i->GetX(),
2531 y = i->GetY();
2532 if ( below )
2533 {
2534 y += GetLineHeight(i) - 1;
2535 }
2536
2537 dc.DrawLine( x, y, x + i->GetWidth(), y);
2538}
2539
2540// -----------------------------------------------------------------------------
2541// wxWidgets callbacks
2542// -----------------------------------------------------------------------------
2543
2544void wxGenericTreeCtrl::OnPaint( wxPaintEvent &WXUNUSED(event) )
2545{
2546 wxPaintDC dc(this);
2547 PrepareDC( dc );
2548
2549 if ( !m_anchor)
2550 return;
2551
2552 dc.SetFont( m_normalFont );
2553 dc.SetPen( m_dottedPen );
2554
2555 // this is now done dynamically
2556 //if(GetImageList() == NULL)
2557 // m_lineHeight = (int)(dc.GetCharHeight() + 4);
2558
2559 int y = 2;
2560 PaintLevel( m_anchor, dc, 0, y );
2561}
2562
2563void wxGenericTreeCtrl::OnSetFocus( wxFocusEvent &event )
2564{
2565 m_hasFocus = true;
2566
2567 RefreshSelected();
2568
2569 event.Skip();
2570}
2571
2572void wxGenericTreeCtrl::OnKillFocus( wxFocusEvent &event )
2573{
2574 m_hasFocus = false;
2575
2576 RefreshSelected();
2577
2578 event.Skip();
2579}
2580
2581void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
2582{
2583 wxTreeEvent te( wxEVT_COMMAND_TREE_KEY_DOWN, GetId() );
2584 te.m_evtKey = event;
2585 te.SetEventObject( this );
2586 if ( GetEventHandler()->ProcessEvent( te ) )
2587 {
2588 // intercepted by the user code
2589 return;
2590 }
2591
2592 if ( (m_current == 0) || (m_key_current == 0) )
2593 {
2594 event.Skip();
2595 return;
2596 }
2597
2598 // how should the selection work for this event?
2599 bool is_multiple, extended_select, unselect_others;
2600 EventFlagsToSelType(GetWindowStyleFlag(),
2601 event.ShiftDown(),
2602 event.CmdDown(),
2603 is_multiple, extended_select, unselect_others);
2604
2605 // + : Expand
2606 // - : Collaspe
2607 // * : Expand all/Collapse all
2608 // ' ' | return : activate
2609 // up : go up (not last children!)
2610 // down : go down
2611 // left : go to parent
2612 // right : open if parent and go next
2613 // home : go to root
2614 // end : go to last item without opening parents
2615 // alnum : start or continue searching for the item with this prefix
2616 int keyCode = event.GetKeyCode();
2617 switch ( keyCode )
2618 {
2619 case '+':
2620 case WXK_ADD:
2621 if (m_current->HasPlus() && !IsExpanded(m_current))
2622 {
2623 Expand(m_current);
2624 }
2625 break;
2626
2627 case '*':
2628 case WXK_MULTIPLY:
2629 if ( !IsExpanded(m_current) )
2630 {
2631 // expand all
2632 ExpandAll(m_current);
2633 break;
2634 }
2635 //else: fall through to Collapse() it
2636
2637 case '-':
2638 case WXK_SUBTRACT:
2639 if (IsExpanded(m_current))
2640 {
2641 Collapse(m_current);
2642 }
2643 break;
2644
2645 case WXK_MENU:
2646 {
2647 // Use the item's bounding rectangle to determine position for the event
2648 wxRect ItemRect;
2649 GetBoundingRect(m_current, ItemRect, true);
2650
2651 wxTreeEvent eventMenu( wxEVT_COMMAND_TREE_ITEM_MENU, GetId() );
2652 eventMenu.m_item = m_current;
2653 // Use the left edge, vertical middle
2654 eventMenu.m_pointDrag = wxPoint(ItemRect.GetX(),
2655 ItemRect.GetY() + ItemRect.GetHeight() / 2);
2656 eventMenu.SetEventObject( this );
2657 GetEventHandler()->ProcessEvent( eventMenu );
2658 break;
2659 }
2660 case ' ':
2661 case WXK_RETURN:
2662 if ( !event.HasModifiers() )
2663 {
2664 wxTreeEvent eventAct( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
2665 eventAct.m_item = m_current;
2666 eventAct.SetEventObject( this );
2667 GetEventHandler()->ProcessEvent( eventAct );
2668 }
2669
2670 // in any case, also generate the normal key event for this key,
2671 // even if we generated the ACTIVATED event above: this is what
2672 // wxMSW does and it makes sense because you might not want to
2673 // process ACTIVATED event at all and handle Space and Return
2674 // directly (and differently) which would be impossible otherwise
2675 event.Skip();
2676 break;
2677
2678 // up goes to the previous sibling or to the last
2679 // of its children if it's expanded
2680 case WXK_UP:
2681 {
2682 wxTreeItemId prev = GetPrevSibling( m_key_current );
2683 if (!prev)
2684 {
2685 prev = GetItemParent( m_key_current );
2686 if ((prev == GetRootItem()) && HasFlag(wxTR_HIDE_ROOT))
2687 {
2688 break; // don't go to root if it is hidden
2689 }
2690 if (prev)
2691 {
2692 wxTreeItemIdValue cookie;
2693 wxTreeItemId current = m_key_current;
2694 // TODO: Huh? If we get here, we'd better be the first child of our parent. How else could it be?
2695 if (current == GetFirstChild( prev, cookie ))
2696 {
2697 // otherwise we return to where we came from
2698 DoSelectItem( prev, unselect_others, extended_select );
2699 m_key_current= (wxGenericTreeItem*) prev.m_pItem;
2700 break;
2701 }
2702 }
2703 }
2704 if (prev)
2705 {
2706 while ( IsExpanded(prev) && HasChildren(prev) )
2707 {
2708 wxTreeItemId child = GetLastChild(prev);
2709 if ( child )
2710 {
2711 prev = child;
2712 }
2713 }
2714
2715 DoSelectItem( prev, unselect_others, extended_select );
2716 m_key_current=(wxGenericTreeItem*) prev.m_pItem;
2717 }
2718 }
2719 break;
2720
2721 // left arrow goes to the parent
2722 case WXK_LEFT:
2723 {
2724 wxTreeItemId prev = GetItemParent( m_current );
2725 if ((prev == GetRootItem()) && HasFlag(wxTR_HIDE_ROOT))
2726 {
2727 // don't go to root if it is hidden
2728 prev = GetPrevSibling( m_current );
2729 }
2730 if (prev)
2731 {
2732 DoSelectItem( prev, unselect_others, extended_select );
2733 }
2734 }
2735 break;
2736
2737 case WXK_RIGHT:
2738 // this works the same as the down arrow except that we
2739 // also expand the item if it wasn't expanded yet
2740 Expand(m_current);
2741 // fall through
2742
2743 case WXK_DOWN:
2744 {
2745 if (IsExpanded(m_key_current) && HasChildren(m_key_current))
2746 {
2747 wxTreeItemIdValue cookie;
2748 wxTreeItemId child = GetFirstChild( m_key_current, cookie );
2749 DoSelectItem( child, unselect_others, extended_select );
2750 m_key_current=(wxGenericTreeItem*) child.m_pItem;
2751 }
2752 else
2753 {
2754 wxTreeItemId next = GetNextSibling( m_key_current );
2755 if (!next)
2756 {
2757 wxTreeItemId current = m_key_current;
2758 while (current.IsOk() && !next)
2759 {
2760 current = GetItemParent( current );
2761 if (current) next = GetNextSibling( current );
2762 }
2763 }
2764 if (next)
2765 {
2766 DoSelectItem( next, unselect_others, extended_select );
2767 m_key_current=(wxGenericTreeItem*) next.m_pItem;
2768 }
2769 }
2770 }
2771 break;
2772
2773 // <End> selects the last visible tree item
2774 case WXK_END:
2775 {
2776 wxTreeItemId last = GetRootItem();
2777
2778 while ( last.IsOk() && IsExpanded(last) )
2779 {
2780 wxTreeItemId lastChild = GetLastChild(last);
2781
2782 // it may happen if the item was expanded but then all of
2783 // its children have been deleted - so IsExpanded() returned
2784 // true, but GetLastChild() returned invalid item
2785 if ( !lastChild )
2786 break;
2787
2788 last = lastChild;
2789 }
2790
2791 if ( last.IsOk() )
2792 {
2793 DoSelectItem( last, unselect_others, extended_select );
2794 }
2795 }
2796 break;
2797
2798 // <Home> selects the root item
2799 case WXK_HOME:
2800 {
2801 wxTreeItemId prev = GetRootItem();
2802 if (!prev)
2803 break;
2804
2805 if ( HasFlag(wxTR_HIDE_ROOT) )
2806 {
2807 wxTreeItemIdValue cookie;
2808 prev = GetFirstChild(prev, cookie);
2809 if (!prev)
2810 break;
2811 }
2812
2813 DoSelectItem( prev, unselect_others, extended_select );
2814 }
2815 break;
2816
2817 default:
2818 // do not use wxIsalnum() here
2819 if ( !event.HasModifiers() &&
2820 ((keyCode >= '0' && keyCode <= '9') ||
2821 (keyCode >= 'a' && keyCode <= 'z') ||
2822 (keyCode >= 'A' && keyCode <= 'Z' )))
2823 {
2824 // find the next item starting with the given prefix
2825 wxChar ch = (wxChar)keyCode;
2826
2827 wxTreeItemId id = FindItem(m_current, m_findPrefix + ch);
2828 if ( !id.IsOk() )
2829 {
2830 // no such item
2831 break;
2832 }
2833
2834 SelectItem(id);
2835
2836 m_findPrefix += ch;
2837
2838 // also start the timer to reset the current prefix if the user
2839 // doesn't press any more alnum keys soon -- we wouldn't want
2840 // to use this prefix for a new item search
2841 if ( !m_findTimer )
2842 {
2843 m_findTimer = new wxTreeFindTimer(this);
2844 }
2845
2846 m_findTimer->Start(wxTreeFindTimer::DELAY, wxTIMER_ONE_SHOT);
2847 }
2848 else
2849 {
2850 event.Skip();
2851 }
2852 }
2853}
2854
2855wxTreeItemId
2856wxGenericTreeCtrl::DoTreeHitTest(const wxPoint& point, int& flags) const
2857{
2858 int w, h;
2859 GetSize(&w, &h);
2860 flags=0;
2861 if (point.x<0) flags |= wxTREE_HITTEST_TOLEFT;
2862 if (point.x>w) flags |= wxTREE_HITTEST_TORIGHT;
2863 if (point.y<0) flags |= wxTREE_HITTEST_ABOVE;
2864 if (point.y>h) flags |= wxTREE_HITTEST_BELOW;
2865 if (flags) return wxTreeItemId();
2866
2867 if (m_anchor == NULL)
2868 {
2869 flags = wxTREE_HITTEST_NOWHERE;
2870 return wxTreeItemId();
2871 }
2872
2873 wxGenericTreeItem *hit = m_anchor->HitTest(CalcUnscrolledPosition(point),
2874 this, flags, 0);
2875 if (hit == NULL)
2876 {
2877 flags = wxTREE_HITTEST_NOWHERE;
2878 return wxTreeItemId();
2879 }
2880 return hit;
2881}
2882
2883// get the bounding rectangle of the item (or of its label only)
2884bool wxGenericTreeCtrl::GetBoundingRect(const wxTreeItemId& item,
2885 wxRect& rect,
2886 bool textOnly) const
2887{
2888 wxCHECK_MSG( item.IsOk(), false, _T("invalid item in wxGenericTreeCtrl::GetBoundingRect") );
2889
2890 wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
2891
2892 if ( textOnly )
2893 {
2894 rect.x = i->GetX();
2895 rect.width = i->GetWidth();
2896
2897 if ( m_imageListNormal )
2898 {
2899 int image_w, image_h;
2900 m_imageListNormal->GetSize( 0, image_w, image_h );
2901 rect.width += image_w + MARGIN_BETWEEN_IMAGE_AND_TEXT;
2902 }
2903 }
2904 else // the entire line
2905 {
2906 rect.x = 0;
2907 rect.width = GetClientSize().x;
2908 }
2909
2910 rect.y = i->GetY();
2911 rect.height = GetLineHeight(i);
2912
2913 // we have to return the logical coordinates, not physical ones
2914 rect.SetTopLeft(CalcScrolledPosition(rect.GetTopLeft()));
2915
2916 return true;
2917}
2918
2919wxTextCtrl *wxGenericTreeCtrl::EditLabel(const wxTreeItemId& item,
2920 wxClassInfo * WXUNUSED(textCtrlClass))
2921{
2922 wxCHECK_MSG( item.IsOk(), NULL, _T("can't edit an invalid item") );
2923
2924 wxGenericTreeItem *itemEdit = (wxGenericTreeItem *)item.m_pItem;
2925
2926 wxTreeEvent te( wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, GetId() );
2927 te.m_item = itemEdit;
2928 te.SetEventObject( this );
2929 if ( GetEventHandler()->ProcessEvent( te ) && !te.IsAllowed() )
2930 {
2931 // vetoed by user
2932 return NULL;
2933 }
2934
2935 // We have to call this here because the label in
2936 // question might just have been added and no screen
2937 // update taken place.
2938 if ( m_dirty )
2939#if defined( __WXMSW__ ) || defined(__WXMAC__)
2940 Update();
2941#else
2942 wxYieldIfNeeded();
2943#endif
2944
2945 // TODO: use textCtrlClass here to create the control of correct class
2946 m_textCtrl = new wxTreeTextCtrl(this, itemEdit);
2947
2948 m_textCtrl->SetFocus();
2949
2950 return m_textCtrl;
2951}
2952
2953// returns a pointer to the text edit control if the item is being
2954// edited, NULL otherwise (it's assumed that no more than one item may
2955// be edited simultaneously)
2956wxTextCtrl* wxGenericTreeCtrl::GetEditControl() const
2957{
2958 return m_textCtrl;
2959}
2960
2961void wxGenericTreeCtrl::EndEditLabel(const wxTreeItemId& WXUNUSED(item),
2962 bool discardChanges)
2963{
2964 wxCHECK_RET( m_textCtrl, _T("not editing label") );
2965
2966 m_textCtrl->EndEdit(discardChanges);
2967}
2968
2969bool wxGenericTreeCtrl::OnRenameAccept(wxGenericTreeItem *item,
2970 const wxString& value)
2971{
2972 wxTreeEvent le( wxEVT_COMMAND_TREE_END_LABEL_EDIT, GetId() );
2973 le.m_item = item;
2974 le.SetEventObject( this );
2975 le.m_label = value;
2976 le.m_editCancelled = false;
2977
2978 return !GetEventHandler()->ProcessEvent( le ) || le.IsAllowed();
2979}
2980
2981void wxGenericTreeCtrl::OnRenameCancelled(wxGenericTreeItem *item)
2982{
2983 // let owner know that the edit was cancelled
2984 wxTreeEvent le( wxEVT_COMMAND_TREE_END_LABEL_EDIT, GetId() );
2985 le.m_item = item;
2986 le.SetEventObject( this );
2987 le.m_label = wxEmptyString;
2988 le.m_editCancelled = true;
2989
2990 GetEventHandler()->ProcessEvent( le );
2991}
2992
2993void wxGenericTreeCtrl::OnRenameTimer()
2994{
2995 EditLabel( m_current );
2996}
2997
2998void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
2999{
3000 if ( !m_anchor ) return;
3001
3002 wxPoint pt = CalcUnscrolledPosition(event.GetPosition());
3003
3004 // Is the mouse over a tree item button?
3005 int flags = 0;
3006 wxGenericTreeItem *thisItem = m_anchor->HitTest(pt, this, flags, 0);
3007 wxGenericTreeItem *underMouse = thisItem;
3008#if wxUSE_TOOLTIPS
3009 bool underMouseChanged = (underMouse != m_underMouse) ;
3010#endif // wxUSE_TOOLTIPS
3011
3012 if ((underMouse) &&
3013 (flags & wxTREE_HITTEST_ONITEMBUTTON) &&
3014 (!event.LeftIsDown()) &&
3015 (!m_isDragging) &&
3016 (!m_renameTimer || !m_renameTimer->IsRunning()))
3017 {
3018 }
3019 else
3020 {
3021 underMouse = NULL;
3022 }
3023
3024 if (underMouse != m_underMouse)
3025 {
3026 if (m_underMouse)
3027 {
3028 // unhighlight old item
3029 wxGenericTreeItem *tmp = m_underMouse;
3030 m_underMouse = NULL;
3031 RefreshLine( tmp );
3032 }
3033
3034 m_underMouse = underMouse;
3035 if (m_underMouse)
3036 RefreshLine( m_underMouse );
3037 }
3038
3039#if wxUSE_TOOLTIPS
3040 // Determines what item we are hovering over and need a tooltip for
3041 wxTreeItemId hoverItem = thisItem;
3042
3043 // We do not want a tooltip if we are dragging, or if the rename timer is running
3044 if (underMouseChanged && hoverItem.IsOk() && !m_isDragging && (!m_renameTimer || !m_renameTimer->IsRunning()))
3045 {
3046 // Ask the tree control what tooltip (if any) should be shown
3047 wxTreeEvent hevent(wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP, GetId());
3048 hevent.m_item = hoverItem;
3049 hevent.SetEventObject(this);
3050
3051 if ( GetEventHandler()->ProcessEvent(hevent) && hevent.IsAllowed() )
3052 {
3053 SetToolTip(hevent.m_label);
3054 }
3055 }
3056#endif
3057
3058 // we process left mouse up event (enables in-place edit), right down
3059 // (pass to the user code), left dbl click (activate item) and
3060 // dragging/moving events for items drag-and-drop
3061 if ( !(event.LeftDown() ||
3062 event.LeftUp() ||
3063 event.RightDown() ||
3064 event.LeftDClick() ||
3065 event.Dragging() ||
3066 ((event.Moving() || event.RightUp()) && m_isDragging)) )
3067 {
3068 event.Skip();
3069
3070 return;
3071 }
3072
3073
3074 flags = 0;
3075 wxGenericTreeItem *item = m_anchor->HitTest(pt, this, flags, 0);
3076
3077 if ( event.Dragging() && !m_isDragging )
3078 {
3079 if (m_dragCount == 0)
3080 m_dragStart = pt;
3081
3082 m_dragCount++;
3083
3084 if (m_dragCount != 3)
3085 {
3086 // wait until user drags a bit further...
3087 return;
3088 }
3089
3090 wxEventType command = event.RightIsDown()
3091 ? wxEVT_COMMAND_TREE_BEGIN_RDRAG
3092 : wxEVT_COMMAND_TREE_BEGIN_DRAG;
3093
3094 wxTreeEvent nevent( command, GetId() );
3095 nevent.m_item = m_current;
3096 nevent.SetEventObject(this);
3097 nevent.SetPoint(CalcScrolledPosition(pt));
3098
3099 // by default the dragging is not supported, the user code must
3100 // explicitly allow the event for it to take place
3101 nevent.Veto();
3102
3103 if ( GetEventHandler()->ProcessEvent(nevent) && nevent.IsAllowed() )
3104 {
3105 // we're going to drag this item
3106 m_isDragging = true;
3107
3108 // remember the old cursor because we will change it while
3109 // dragging
3110 m_oldCursor = m_cursor;
3111
3112 // in a single selection control, hide the selection temporarily
3113 if ( !(GetWindowStyleFlag() & wxTR_MULTIPLE) )
3114 {
3115 m_oldSelection = (wxGenericTreeItem*) GetSelection().m_pItem;
3116
3117 if ( m_oldSelection )
3118 {
3119 m_oldSelection->SetHilight(false);
3120 RefreshLine(m_oldSelection);
3121 }
3122 }
3123
3124 CaptureMouse();
3125 }
3126 }
3127 else if ( event.Dragging() )
3128 {
3129 if ( item != m_dropTarget )
3130 {
3131 // unhighlight the previous drop target
3132 DrawDropEffect(m_dropTarget);
3133
3134 m_dropTarget = item;
3135
3136 // highlight the current drop target if any
3137 DrawDropEffect(m_dropTarget);
3138
3139#if defined(__WXMSW__) || defined(__WXMAC__) || defined(__WXGTK20__)
3140 Update();
3141#else
3142 wxYieldIfNeeded();
3143#endif
3144 }
3145 }
3146 else if ( (event.LeftUp() || event.RightUp()) && m_isDragging )
3147 {
3148 ReleaseMouse();
3149
3150 // erase the highlighting
3151 DrawDropEffect(m_dropTarget);
3152
3153 if ( m_oldSelection )
3154 {
3155 m_oldSelection->SetHilight(true);
3156 RefreshLine(m_oldSelection);
3157 m_oldSelection = (wxGenericTreeItem *)NULL;
3158 }
3159
3160 // generate the drag end event
3161 wxTreeEvent eventEndDrag(wxEVT_COMMAND_TREE_END_DRAG, GetId());
3162
3163 eventEndDrag.m_item = item;
3164 eventEndDrag.m_pointDrag = CalcScrolledPosition(pt);
3165 eventEndDrag.SetEventObject(this);
3166
3167 (void)GetEventHandler()->ProcessEvent(eventEndDrag);
3168
3169 m_isDragging = false;
3170 m_dropTarget = (wxGenericTreeItem *)NULL;
3171
3172 SetCursor(m_oldCursor);
3173
3174#if defined( __WXMSW__ ) || defined(__WXMAC__)
3175 Update();
3176#else
3177 wxYieldIfNeeded();
3178#endif
3179 }
3180 else
3181 {
3182 // If we got to this point, we are not dragging or moving the mouse.
3183 // Because the code in carbon/toplevel.cpp will only set focus to the tree
3184 // if we skip for EVT_LEFT_DOWN, we MUST skip this event here for focus to work.
3185 // We skip even if we didn't hit an item because we still should
3186 // restore focus to the tree control even if we didn't exactly hit an item.
3187 if ( event.LeftDown() )
3188 {
3189 event.Skip();
3190 }
3191
3192 // here we process only the messages which happen on tree items
3193
3194 m_dragCount = 0;
3195
3196 if (item == NULL) return; /* we hit the blank area */
3197
3198 if ( event.RightDown() )
3199 {
3200 // If the item is already selected, do not update the selection.
3201 // Multi-selections should not be cleared if a selected item is clicked.
3202 if (!IsSelected(item))
3203 {
3204 DoSelectItem(item, true, false);
3205 }
3206
3207 wxTreeEvent nevent(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK, GetId());
3208 nevent.m_item = item;
3209 nevent.m_pointDrag = CalcScrolledPosition(pt);
3210 nevent.SetEventObject(this);
3211 event.Skip(!GetEventHandler()->ProcessEvent(nevent));
3212
3213 // Consistent with MSW (for now), send the ITEM_MENU *after*
3214 // the RIGHT_CLICK event. TODO: This behavior may change.
3215 wxTreeEvent nevent2(wxEVT_COMMAND_TREE_ITEM_MENU, GetId());
3216 nevent2.m_item = item;
3217 nevent2.m_pointDrag = CalcScrolledPosition(pt);
3218 nevent2.SetEventObject(this);
3219 GetEventHandler()->ProcessEvent(nevent2);
3220 }
3221 else if ( event.LeftUp() )
3222 {
3223 // this facilitates multiple-item drag-and-drop
3224
3225 if ( /* item && */ HasFlag(wxTR_MULTIPLE))
3226 {
3227 wxArrayTreeItemIds selections;
3228 size_t count = GetSelections(selections);
3229
3230 if (count > 1 &&
3231 !event.CmdDown() &&
3232 !event.ShiftDown())
3233 {
3234 DoSelectItem(item, true, false);
3235 }
3236 }
3237
3238 if ( m_lastOnSame )
3239 {
3240 if ( (item == m_current) &&
3241 (flags & wxTREE_HITTEST_ONITEMLABEL) &&
3242 HasFlag(wxTR_EDIT_LABELS) )
3243 {
3244 if ( m_renameTimer )
3245 {
3246 if ( m_renameTimer->IsRunning() )
3247 m_renameTimer->Stop();
3248 }
3249 else
3250 {
3251 m_renameTimer = new wxTreeRenameTimer( this );
3252 }
3253
3254 m_renameTimer->Start( wxTreeRenameTimer::DELAY, true );
3255 }
3256
3257 m_lastOnSame = false;
3258 }
3259 }
3260 else // !RightDown() && !LeftUp() ==> LeftDown() || LeftDClick()
3261 {
3262 if ( event.LeftDown() )
3263 {
3264 m_lastOnSame = item == m_current;
3265 }
3266
3267 if ( flags & wxTREE_HITTEST_ONITEMBUTTON )
3268 {
3269 // only toggle the item for a single click, double click on
3270 // the button doesn't do anything (it toggles the item twice)
3271 if ( event.LeftDown() )
3272 {
3273 Toggle( item );
3274 }
3275
3276 // don't select the item if the button was clicked
3277 return;
3278 }
3279
3280
3281 // clear the previously selected items, if the
3282 // user clicked outside of the present selection.
3283 // otherwise, perform the deselection on mouse-up.
3284 // this allows multiple drag and drop to work.
3285 // but if Cmd is down, toggle selection of the clicked item
3286 if (!IsSelected(item) || event.CmdDown())
3287 {
3288 // how should the selection work for this event?
3289 bool is_multiple, extended_select, unselect_others;
3290 EventFlagsToSelType(GetWindowStyleFlag(),
3291 event.ShiftDown(),
3292 event.CmdDown(),
3293 is_multiple, extended_select, unselect_others);
3294
3295 DoSelectItem(item, unselect_others, extended_select);
3296 }
3297
3298
3299 // For some reason, Windows isn't recognizing a left double-click,
3300 // so we need to simulate it here. Allow 200 milliseconds for now.
3301 if ( event.LeftDClick() )
3302 {
3303 // double clicking should not start editing the item label
3304 if ( m_renameTimer )
3305 m_renameTimer->Stop();
3306
3307 m_lastOnSame = false;
3308
3309 // send activate event first
3310 wxTreeEvent nevent( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
3311 nevent.m_item = item;
3312 nevent.m_pointDrag = CalcScrolledPosition(pt);
3313 nevent.SetEventObject( this );
3314 if ( !GetEventHandler()->ProcessEvent( nevent ) )
3315 {
3316 // if the user code didn't process the activate event,
3317 // handle it ourselves by toggling the item when it is
3318 // double clicked
3319 if ( item->HasPlus() )
3320 {
3321 Toggle(item);
3322 }
3323 }
3324 }
3325 }
3326 }
3327}
3328
3329void wxGenericTreeCtrl::OnInternalIdle()
3330{
3331 wxWindow::OnInternalIdle();
3332
3333 // Check if we need to select the root item
3334 // because nothing else has been selected.
3335 // Delaying it means that we can invoke event handlers
3336 // as required, when a first item is selected.
3337 if (!HasFlag(wxTR_MULTIPLE) && !GetSelection().IsOk())
3338 {
3339 if (m_select_me)
3340 SelectItem(m_select_me);
3341 else if (GetRootItem().IsOk())
3342 SelectItem(GetRootItem());
3343 }
3344
3345 /* after all changes have been done to the tree control,
3346 * we actually redraw the tree when everything is over */
3347
3348 if (!m_dirty) return;
3349 if (m_freezeCount) return;
3350
3351 m_dirty = false;
3352
3353 CalculatePositions();
3354 Refresh();
3355 AdjustMyScrollbars();
3356}
3357
3358void wxGenericTreeCtrl::CalculateSize( wxGenericTreeItem *item, wxDC &dc )
3359{
3360 wxCoord text_w = 0;
3361 wxCoord text_h = 0;
3362
3363 wxTreeItemAttr *attr = item->GetAttributes();
3364 if ( attr && attr->HasFont() )
3365 dc.SetFont(attr->GetFont());
3366 else if ( item->IsBold() )
3367 dc.SetFont(m_boldFont);
3368 else
3369 dc.SetFont(m_normalFont);
3370
3371 dc.GetTextExtent( item->GetText(), &text_w, &text_h );
3372 text_h+=2;
3373
3374 // restore normal font
3375 dc.SetFont( m_normalFont );
3376
3377 int image_h = 0;
3378 int image_w = 0;
3379 int image = item->GetCurrentImage();
3380 if ( image != NO_IMAGE )
3381 {
3382 if ( m_imageListNormal )
3383 {
3384 m_imageListNormal->GetSize( image, image_w, image_h );
3385 image_w += MARGIN_BETWEEN_IMAGE_AND_TEXT;
3386 }
3387 }
3388
3389 int total_h = (image_h > text_h) ? image_h : text_h;
3390
3391 if (total_h < 30)
3392 total_h += 2; // at least 2 pixels
3393 else
3394 total_h += total_h/10; // otherwise 10% extra spacing
3395
3396 item->SetHeight(total_h);
3397 if (total_h>m_lineHeight)
3398 m_lineHeight=total_h;
3399
3400 item->SetWidth(image_w+text_w+2);
3401}
3402
3403// -----------------------------------------------------------------------------
3404// for developper : y is now the top of the level
3405// not the middle of it !
3406void wxGenericTreeCtrl::CalculateLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y )
3407{
3408 int x = level*m_indent;
3409 if (!HasFlag(wxTR_HIDE_ROOT))
3410 {
3411 x += m_indent;
3412 }
3413 else if (level == 0)
3414 {
3415 // a hidden root is not evaluated, but its
3416 // children are always calculated
3417 goto Recurse;
3418 }
3419
3420 CalculateSize( item, dc );
3421
3422 // set its position
3423 item->SetX( x+m_spacing );
3424 item->SetY( y );
3425 y += GetLineHeight(item);
3426
3427 if ( !item->IsExpanded() )
3428 {
3429 // we don't need to calculate collapsed branches
3430 return;
3431 }
3432
3433 Recurse:
3434 wxArrayGenericTreeItems& children = item->GetChildren();
3435 size_t n, count = children.Count();
3436 ++level;
3437 for (n = 0; n < count; ++n )
3438 CalculateLevel( children[n], dc, level, y ); // recurse
3439}
3440
3441void wxGenericTreeCtrl::CalculatePositions()
3442{
3443 if ( !m_anchor ) return;
3444
3445 wxClientDC dc(this);
3446 PrepareDC( dc );
3447
3448 dc.SetFont( m_normalFont );
3449
3450 dc.SetPen( m_dottedPen );
3451 //if(GetImageList() == NULL)
3452 // m_lineHeight = (int)(dc.GetCharHeight() + 4);
3453
3454 int y = 2;
3455 CalculateLevel( m_anchor, dc, 0, y ); // start recursion
3456}
3457
3458void wxGenericTreeCtrl::RefreshSubtree(wxGenericTreeItem *item)
3459{
3460 if (m_dirty) return;
3461 if (m_freezeCount) return;
3462
3463 wxSize client = GetClientSize();
3464
3465 wxRect rect;
3466 CalcScrolledPosition(0, item->GetY(), NULL, &rect.y);
3467 rect.width = client.x;
3468 rect.height = client.y;
3469
3470 Refresh(true, &rect);
3471
3472 AdjustMyScrollbars();
3473}
3474
3475void wxGenericTreeCtrl::RefreshLine( wxGenericTreeItem *item )
3476{
3477 if (m_dirty) return;
3478 if (m_freezeCount) return;
3479
3480 wxRect rect;
3481 CalcScrolledPosition(0, item->GetY(), NULL, &rect.y);
3482 rect.width = GetClientSize().x;
3483 rect.height = GetLineHeight(item); //dc.GetCharHeight() + 6;
3484
3485 Refresh(true, &rect);
3486}
3487
3488void wxGenericTreeCtrl::RefreshSelected()
3489{
3490 if (m_freezeCount) return;
3491
3492 // TODO: this is awfully inefficient, we should keep the list of all
3493 // selected items internally, should be much faster
3494 if ( m_anchor )
3495 RefreshSelectedUnder(m_anchor);
3496}
3497
3498void wxGenericTreeCtrl::RefreshSelectedUnder(wxGenericTreeItem *item)
3499{
3500 if (m_freezeCount) return;
3501
3502 if ( item->IsSelected() )
3503 RefreshLine(item);
3504
3505 const wxArrayGenericTreeItems& children = item->GetChildren();
3506 size_t count = children.GetCount();
3507 for ( size_t n = 0; n < count; n++ )
3508 {
3509 RefreshSelectedUnder(children[n]);
3510 }
3511}
3512
3513void wxGenericTreeCtrl::Freeze()
3514{
3515 m_freezeCount++;
3516}
3517
3518void wxGenericTreeCtrl::Thaw()
3519{
3520 wxCHECK_RET( m_freezeCount > 0, _T("thawing unfrozen tree control?") );
3521
3522 if ( --m_freezeCount == 0 )
3523 {
3524 Refresh();
3525 }
3526}
3527
3528// ----------------------------------------------------------------------------
3529// changing colours: we need to refresh the tree control
3530// ----------------------------------------------------------------------------
3531
3532bool wxGenericTreeCtrl::SetBackgroundColour(const wxColour& colour)
3533{
3534 if ( !wxWindow::SetBackgroundColour(colour) )
3535 return false;
3536
3537 if (m_freezeCount) return true;
3538
3539 Refresh();
3540
3541 return true;
3542}
3543
3544bool wxGenericTreeCtrl::SetForegroundColour(const wxColour& colour)
3545{
3546 if ( !wxWindow::SetForegroundColour(colour) )
3547 return false;
3548
3549 if (m_freezeCount) return true;
3550
3551 Refresh();
3552
3553 return true;
3554}
3555
3556// Process the tooltip event, to speed up event processing.
3557// Doesn't actually get a tooltip.
3558void wxGenericTreeCtrl::OnGetToolTip( wxTreeEvent &event )
3559{
3560 event.Veto();
3561}
3562
3563
3564// NOTE: If using the wxListBox visual attributes works everywhere then this can
3565// be removed, as well as the #else case below.
3566#define _USE_VISATTR 0
3567
3568//static
3569wxVisualAttributes
3570#if _USE_VISATTR
3571wxGenericTreeCtrl::GetClassDefaultAttributes(wxWindowVariant variant)
3572#else
3573wxGenericTreeCtrl::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
3574#endif
3575{
3576#if _USE_VISATTR
3577 // Use the same color scheme as wxListBox
3578 return wxListBox::GetClassDefaultAttributes(variant);
3579#else
3580 wxVisualAttributes attr;
3581 attr.colFg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
3582 attr.colBg = wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOX);
3583 attr.font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
3584 return attr;
3585#endif
3586}
3587
3588#if WXWIN_COMPATIBILITY_2_4
3589
3590int wxGenericTreeCtrl::GetItemSelectedImage(const wxTreeItemId& item) const
3591{
3592 return GetItemImage(item, wxTreeItemIcon_Selected);
3593}
3594
3595void wxGenericTreeCtrl::SetItemSelectedImage(const wxTreeItemId& item, int image)
3596{
3597 SetItemImage(item, image, wxTreeItemIcon_Selected);
3598}
3599
3600#endif // WXWIN_COMPATIBILITY_2_4
3601
3602#endif // wxUSE_TREECTRL