]> git.saurik.com Git - wxWidgets.git/blob - src/generic/treectrl.cpp
projects / wxWidgets.git / blob
? search:


dc7160f2945ef82847369e31904c3eecdd816f94
[wxWidgets.git] / src / generic / treectrl.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: treectrl.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, Julian Smart and Markus Holzem
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // =============================================================================
13 // declarations
14 // =============================================================================
15
16 // -----------------------------------------------------------------------------
17 // headers
18 // -----------------------------------------------------------------------------
19
20 #ifdef __GNUG__
21 #pragma implementation "treectrl.h"
22 #endif
23
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
26
27 #ifdef __BORLANDC__
28 #pragma hdrstop
29 #endif
30
31 #include "wx/treectrl.h"
32 #include "wx/generic/imaglist.h"
33 #include "wx/settings.h"
34 #include "wx/log.h"
35 #include "wx/intl.h"
36 #include "wx/dynarray.h"
37 #include "wx/arrimpl.cpp"
38 #include "wx/dcclient.h"
39 #include "wx/msgdlg.h"
40
41 // -----------------------------------------------------------------------------
42 // array types
43 // -----------------------------------------------------------------------------
44
45 class WXDLLEXPORT wxGenericTreeItem;
46
47 WX_DEFINE_ARRAY(wxGenericTreeItem *, wxArrayGenericTreeItems);
48 WX_DEFINE_OBJARRAY(wxArrayTreeItemIds);
49
50 // ----------------------------------------------------------------------------
51 // constants
52 // ----------------------------------------------------------------------------
53
54 static const int NO_IMAGE = -1;
55
56 #define PIXELS_PER_UNIT 10
57
58 // -----------------------------------------------------------------------------
59 // private classes
60 // -----------------------------------------------------------------------------
61
62 // timer used for enabling in-place edit
63 class WXDLLEXPORT wxTreeRenameTimer: public wxTimer
64 {
65 public:
66 wxTreeRenameTimer( wxTreeCtrl *owner );
67
68 void Notify();
69
70 private:
71 wxTreeCtrl *m_owner;
72 };
73
74 // control used for in-place edit
75 class WXDLLEXPORT wxTreeTextCtrl: public wxTextCtrl
76 {
77 public:
78 wxTreeTextCtrl() { }
79 wxTreeTextCtrl( wxWindow *parent,
80 const wxWindowID id,
81 bool *accept,
82 wxString *res,
83 wxTreeCtrl *owner,
84 const wxString &value = wxEmptyString,
85 const wxPoint &pos = wxDefaultPosition,
86 const wxSize &size = wxDefaultSize,
87 int style = 0,
88 const wxValidator& validator = wxDefaultValidator,
89 const wxString &name = wxTextCtrlNameStr );
90
91 void OnChar( wxKeyEvent &event );
92 void OnKillFocus( wxFocusEvent &event );
93
94 private:
95 bool *m_accept;
96 wxString *m_res;
97 wxTreeCtrl *m_owner;
98 wxString m_startValue;
99
100 DECLARE_EVENT_TABLE()
101 DECLARE_DYNAMIC_CLASS(wxTreeTextCtrl);
102 };
103
104 // a tree item
105 class WXDLLEXPORT wxGenericTreeItem
106 {
107 public:
108 // ctors & dtor
109 wxGenericTreeItem() { m_data = NULL; }
110 wxGenericTreeItem( wxGenericTreeItem *parent,
111 const wxString& text,
112 wxDC& dc,
113 int image, int selImage,
114 wxTreeItemData *data );
115
116 ~wxGenericTreeItem();
117
118 // trivial accessors
119 wxArrayGenericTreeItems& GetChildren() { return m_children; }
120
121 const wxString& GetText() const { return m_text; }
122 int GetImage(wxTreeItemIcon which = wxTreeItemIcon_Normal) const
123 { return m_images[which]; }
124 wxTreeItemData *GetData() const { return m_data; }
125
126 // returns the current image for the item (depending on its
127 // selected/expanded/whatever state)
128 int GetCurrentImage() const;
129
130 void SetText( const wxString &text );
131 void SetImage(int image, wxTreeItemIcon which) { m_images[which] = image; }
132 void SetData(wxTreeItemData *data) { m_data = data; }
133
134 void SetHasPlus(bool has = TRUE) { m_hasPlus = has; }
135
136 void SetBold(bool bold) { m_isBold = bold; }
137
138 int GetX() const { return m_x; }
139 int GetY() const { return m_y; }
140
141 void SetX(int x) { m_x = x; }
142 void SetY(int y) { m_y = y; }
143
144 int GetHeight() const { return m_height; }
145 int GetWidth() const { return m_width; }
146
147 void SetHeight(int h) { m_height = h; }
148 void SetWidth(int w) { m_width = w; }
149
150
151 wxGenericTreeItem *GetParent() const { return m_parent; }
152
153 // operations
154 // deletes all children notifying the treectrl about it if !NULL
155 // pointer given
156 void DeleteChildren(wxTreeCtrl *tree = NULL);
157 // FIXME don't know what is it for
158 void Reset();
159
160 // get count of all children (and grand children if 'recursively')
161 size_t GetChildrenCount(bool recursively = TRUE) const;
162
163 void Insert(wxGenericTreeItem *child, size_t index)
164 { m_children.Insert(child, index); }
165
166 void SetCross( int x, int y );
167 void GetSize( int &x, int &y, const wxTreeCtrl* );
168
169 // return the item at given position (or NULL if no item), onButton is
170 // TRUE if the point belongs to the item's button, otherwise it lies
171 // on the button's label
172 wxGenericTreeItem *HitTest( const wxPoint& point, const wxTreeCtrl *, int &flags);
173
174 void Expand() { m_isCollapsed = FALSE; }
175 void Collapse() { m_isCollapsed = TRUE; }
176
177 void SetHilight( bool set = TRUE ) { m_hasHilight = set; }
178
179 // status inquiries
180 bool HasChildren() const { return !m_children.IsEmpty(); }
181 bool IsSelected() const { return m_hasHilight; }
182 bool IsExpanded() const { return !m_isCollapsed; }
183 bool HasPlus() const { return m_hasPlus || HasChildren(); }
184 bool IsBold() const { return m_isBold; }
185
186 // attributes
187 // get them - may be NULL
188 wxTreeItemAttr *GetAttributes() const { return m_attr; }
189 // get them ensuring that the pointer is not NULL
190 wxTreeItemAttr& Attr()
191 {
192 if ( !m_attr )
193 m_attr = new wxTreeItemAttr;
194
195 return *m_attr;
196 }
197
198 private:
199 wxString m_text;
200
201 // tree ctrl images for the normal, selected, expanded and
202 // expanded+selected states
203 int m_images[wxTreeItemIcon_Max];
204
205 wxTreeItemData *m_data;
206
207 // use bitfields to save size
208 int m_isCollapsed :1;
209 int m_hasHilight :1; // same as focused
210 int m_hasPlus :1; // used for item which doesn't have
211 // children but has a [+] button
212 int m_isBold :1; // render the label in bold font
213
214 wxCoord m_x, m_y;
215 wxCoord m_height, m_width;
216 int m_xCross, m_yCross;
217 int m_level;
218
219 wxArrayGenericTreeItems m_children;
220 wxGenericTreeItem *m_parent;
221
222 wxTreeItemAttr *m_attr;
223 };
224
225 // =============================================================================
226 // implementation
227 // =============================================================================
228
229 // ----------------------------------------------------------------------------
230 // private functions
231 // ----------------------------------------------------------------------------
232
233 // translate the key or mouse event flags to the type of selection we're
234 // dealing with
235 static void EventFlagsToSelType(long style,
236 bool shiftDown,
237 bool ctrlDown,
238 bool *is_multiple,
239 bool *extended_select,
240 bool *unselect_others)
241 {
242 *is_multiple = (style & wxTR_MULTIPLE) != 0;
243 *extended_select = shiftDown && is_multiple;
244 *unselect_others = !(extended_select || (ctrlDown && is_multiple));
245 }
246
247 // -----------------------------------------------------------------------------
248 // wxTreeRenameTimer (internal)
249 // -----------------------------------------------------------------------------
250
251 wxTreeRenameTimer::wxTreeRenameTimer( wxTreeCtrl *owner )
252 {
253 m_owner = owner;
254 }
255
256 void wxTreeRenameTimer::Notify()
257 {
258 m_owner->OnRenameTimer();
259 }
260
261 //-----------------------------------------------------------------------------
262 // wxTreeTextCtrl (internal)
263 //-----------------------------------------------------------------------------
264
265 IMPLEMENT_DYNAMIC_CLASS(wxTreeTextCtrl,wxTextCtrl);
266
267 BEGIN_EVENT_TABLE(wxTreeTextCtrl,wxTextCtrl)
268 EVT_CHAR (wxTreeTextCtrl::OnChar)
269 EVT_KILL_FOCUS (wxTreeTextCtrl::OnKillFocus)
270 END_EVENT_TABLE()
271
272 wxTreeTextCtrl::wxTreeTextCtrl( wxWindow *parent,
273 const wxWindowID id,
274 bool *accept,
275 wxString *res,
276 wxTreeCtrl *owner,
277 const wxString &value,
278 const wxPoint &pos,
279 const wxSize &size,
280 int style,
281 const wxValidator& validator,
282 const wxString &name )
283 : wxTextCtrl( parent, id, value, pos, size, style, validator, name )
284 {
285 m_res = res;
286 m_accept = accept;
287 m_owner = owner;
288 (*m_accept) = FALSE;
289 (*m_res) = wxEmptyString;
290 m_startValue = value;
291 }
292
293 void wxTreeTextCtrl::OnChar( wxKeyEvent &event )
294 {
295 if (event.m_keyCode == WXK_RETURN)
296 {
297 (*m_accept) = TRUE;
298 (*m_res) = GetValue();
299
300 if (!wxPendingDelete.Member(this))
301 wxPendingDelete.Append(this);
302
303 if ((*m_accept) && ((*m_res) != m_startValue))
304 m_owner->OnRenameAccept();
305
306 return;
307 }
308 if (event.m_keyCode == WXK_ESCAPE)
309 {
310 (*m_accept) = FALSE;
311 (*m_res) = "";
312
313 if (!wxPendingDelete.Member(this))
314 wxPendingDelete.Append(this);
315
316 return;
317 }
318 event.Skip();
319 }
320
321 void wxTreeTextCtrl::OnKillFocus( wxFocusEvent &WXUNUSED(event) )
322 {
323 if (!wxPendingDelete.Member(this))
324 wxPendingDelete.Append(this);
325
326 if ((*m_accept) && ((*m_res) != m_startValue))
327 m_owner->OnRenameAccept();
328 }
329
330 // -----------------------------------------------------------------------------
331 // wxTreeEvent
332 // -----------------------------------------------------------------------------
333
334 IMPLEMENT_DYNAMIC_CLASS(wxTreeEvent, wxNotifyEvent)
335
336 wxTreeEvent::wxTreeEvent( wxEventType commandType, int id )
337 : wxNotifyEvent( commandType, id )
338 {
339 m_code = 0;
340 m_itemOld = (wxGenericTreeItem *)NULL;
341 }
342
343 // -----------------------------------------------------------------------------
344 // wxGenericTreeItem
345 // -----------------------------------------------------------------------------
346
347 wxGenericTreeItem::wxGenericTreeItem(wxGenericTreeItem *parent,
348 const wxString& text,
349 wxDC& WXUNUSED(dc),
350 int image, int selImage,
351 wxTreeItemData *data)
352 : m_text(text)
353 {
354 m_images[wxTreeItemIcon_Normal] = image;
355 m_images[wxTreeItemIcon_Selected] = selImage;
356 m_images[wxTreeItemIcon_Expanded] = NO_IMAGE;
357 m_images[wxTreeItemIcon_SelectedExpanded] = NO_IMAGE;
358
359 m_data = data;
360 m_x = m_y = 0;
361 m_xCross = m_yCross = 0;
362
363 m_level = 0;
364
365 m_isCollapsed = TRUE;
366 m_hasHilight = FALSE;
367 m_hasPlus = FALSE;
368 m_isBold = FALSE;
369
370 m_parent = parent;
371
372 m_attr = (wxTreeItemAttr *)NULL;
373
374 // We don't know the height here yet.
375 m_width = 0;
376 m_height = 0;
377 }
378
379 wxGenericTreeItem::~wxGenericTreeItem()
380 {
381 delete m_data;
382
383 delete m_attr;
384
385 wxASSERT_MSG( m_children.IsEmpty(),
386 wxT("please call DeleteChildren() before deleting the item") );
387 }
388
389 void wxGenericTreeItem::DeleteChildren(wxTreeCtrl *tree)
390 {
391 size_t count = m_children.Count();
392 for ( size_t n = 0; n < count; n++ )
393 {
394 wxGenericTreeItem *child = m_children[n];
395 if (tree)
396 tree->SendDeleteEvent(child);
397
398 child->DeleteChildren(tree);
399 delete child;
400 }
401
402 m_children.Empty();
403 }
404
405 void wxGenericTreeItem::SetText( const wxString &text )
406 {
407 m_text = text;
408 }
409
410 void wxGenericTreeItem::Reset()
411 {
412 m_text.Empty();
413 for ( int i = 0; i < wxTreeItemIcon_Max; i++ )
414 {
415 m_images[i] = NO_IMAGE;
416 }
417
418 m_data = NULL;
419 m_x = m_y =
420 m_height = m_width = 0;
421 m_xCross =
422 m_yCross = 0;
423
424 m_level = 0;
425
426 DeleteChildren();
427 m_isCollapsed = TRUE;
428
429 m_parent = (wxGenericTreeItem *)NULL;
430 }
431
432 size_t wxGenericTreeItem::GetChildrenCount(bool recursively) const
433 {
434 size_t count = m_children.Count();
435 if ( !recursively )
436 return count;
437
438 size_t total = count;
439 for (size_t n = 0; n < count; ++n)
440 {
441 total += m_children[n]->GetChildrenCount();
442 }
443
444 return total;
445 }
446
447 void wxGenericTreeItem::SetCross( int x, int y )
448 {
449 m_xCross = x;
450 m_yCross = y;
451 }
452
453 void wxGenericTreeItem::GetSize( int &x, int &y, const wxTreeCtrl *theTree )
454 {
455 int bottomY=m_y+theTree->GetLineHeight(this);
456 if ( y < bottomY ) y = bottomY;
457 int width = m_x + m_width;
458 if ( x < width ) x = width;
459
460 if (IsExpanded())
461 {
462 size_t count = m_children.Count();
463 for ( size_t n = 0; n < count; ++n )
464 {
465 m_children[n]->GetSize( x, y, theTree );
466 }
467 }
468 }
469
470 wxGenericTreeItem *wxGenericTreeItem::HitTest( const wxPoint& point,
471 const wxTreeCtrl *theTree,
472 int &flags)
473 {
474 if ((point.y > m_y) && (point.y < m_y + theTree->GetLineHeight(this)))
475 {
476 if (point.y < m_y+theTree->GetLineHeight(this)/2 )
477 flags |= wxTREE_HITTEST_ONITEMUPPERPART;
478 else
479 flags |= wxTREE_HITTEST_ONITEMLOWERPART;
480
481 // 5 is the size of the plus sign
482 if ((point.x > m_xCross-5) && (point.x < m_xCross+5) &&
483 (point.y > m_yCross-5) && (point.y < m_yCross+5) &&
484 (IsExpanded() || HasPlus()))
485 {
486 flags|=wxTREE_HITTEST_ONITEMBUTTON;
487 return this;
488 }
489
490 if ((point.x >= m_x) && (point.x <= m_x+m_width))
491 {
492 int image_w = -1;
493 int image_h;
494
495 // assuming every image (normal and selected ) has the same size !
496 if ( (GetImage() != NO_IMAGE) && theTree->m_imageListNormal )
497 theTree->m_imageListNormal->GetSize(GetImage(), image_w, image_h);
498
499 if ((image_w != -1) && (point.x <= m_x + image_w + 1))
500 flags |= wxTREE_HITTEST_ONITEMICON;
501 else
502 flags |= wxTREE_HITTEST_ONITEMLABEL;
503
504 return this;
505 }
506
507 if (point.x < m_x)
508 flags |= wxTREE_HITTEST_ONITEMINDENT;
509 if (point.x > m_x+m_width)
510 flags |= wxTREE_HITTEST_ONITEMRIGHT;
511
512 return this;
513 }
514 else
515 {
516 if (!m_isCollapsed)
517 {
518 size_t count = m_children.Count();
519 for ( size_t n = 0; n < count; n++ )
520 {
521 wxGenericTreeItem *res = m_children[n]->HitTest( point, theTree, flags );
522 if ( res != NULL )
523 return res;
524 }
525 }
526 }
527
528 flags|=wxTREE_HITTEST_NOWHERE;
529
530 return (wxGenericTreeItem*) NULL;
531 }
532
533 int wxGenericTreeItem::GetCurrentImage() const
534 {
535 int image = NO_IMAGE;
536 if ( IsExpanded() )
537 {
538 if ( IsSelected() )
539 {
540 image = GetImage(wxTreeItemIcon_SelectedExpanded);
541 }
542
543 if ( image == NO_IMAGE )
544 {
545 // we usually fall back to the normal item, but try just the
546 // expanded one (and not selected) first in this case
547 image = GetImage(wxTreeItemIcon_Expanded);
548 }
549 }
550 else // not expanded
551 {
552 if ( IsSelected() )
553 image = GetImage(wxTreeItemIcon_Selected);
554 }
555
556 // may be it doesn't have the specific image we want, try the default one
557 // instead
558 if ( image == NO_IMAGE )
559 {
560 image = GetImage();
561 }
562
563 return image;
564 }
565
566 // -----------------------------------------------------------------------------
567 // wxTreeCtrl implementation
568 // -----------------------------------------------------------------------------
569
570 IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxScrolledWindow)
571
572 BEGIN_EVENT_TABLE(wxTreeCtrl,wxScrolledWindow)
573 EVT_PAINT (wxTreeCtrl::OnPaint)
574 EVT_MOUSE_EVENTS (wxTreeCtrl::OnMouse)
575 EVT_CHAR (wxTreeCtrl::OnChar)
576 EVT_SET_FOCUS (wxTreeCtrl::OnSetFocus)
577 EVT_KILL_FOCUS (wxTreeCtrl::OnKillFocus)
578 EVT_IDLE (wxTreeCtrl::OnIdle)
579 END_EVENT_TABLE()
580
581 // -----------------------------------------------------------------------------
582 // construction/destruction
583 // -----------------------------------------------------------------------------
584
585 void wxTreeCtrl::Init()
586 {
587 m_current =
588 m_key_current =
589 m_anchor = (wxGenericTreeItem *) NULL;
590 m_hasFocus = FALSE;
591 m_dirty = FALSE;
592
593 m_xScroll = 0;
594 m_yScroll = 0;
595 m_lineHeight = 10;
596 m_indent = 15;
597 m_spacing = 18;
598
599 m_hilightBrush = new wxBrush
600 (
601 wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHT),
602 wxSOLID
603 );
604
605 m_imageListNormal =
606 m_imageListState = (wxImageList *) NULL;
607
608 m_dragCount = 0;
609 m_isDragging = FALSE;
610 m_dropTarget =
611 m_oldSelection = (wxGenericTreeItem *)NULL;
612
613 m_renameTimer = new wxTreeRenameTimer( this );
614
615 m_normalFont = wxSystemSettings::GetSystemFont( wxSYS_DEFAULT_GUI_FONT );
616 m_boldFont = wxFont( m_normalFont.GetPointSize(),
617 m_normalFont.GetFamily(),
618 m_normalFont.GetStyle(),
619 wxBOLD,
620 m_normalFont.GetUnderlined());
621 }
622
623 bool wxTreeCtrl::Create(wxWindow *parent, wxWindowID id,
624 const wxPoint& pos, const wxSize& size,
625 long style,
626 const wxValidator &validator,
627 const wxString& name )
628 {
629 Init();
630
631 wxScrolledWindow::Create( parent, id, pos, size, style|wxHSCROLL|wxVSCROLL, name );
632
633 #if wxUSE_VALIDATORS
634 SetValidator( validator );
635 #endif
636
637 SetBackgroundColour( wxSystemSettings::GetSystemColour( wxSYS_COLOUR_LISTBOX ) );
638 // m_dottedPen = wxPen( "grey", 0, wxDOT ); too slow under XFree86
639 m_dottedPen = wxPen( "grey", 0, 0 );
640
641 return TRUE;
642 }
643
644 wxTreeCtrl::~wxTreeCtrl()
645 {
646 wxDELETE( m_hilightBrush );
647
648 DeleteAllItems();
649
650 delete m_renameTimer;
651 }
652
653 // -----------------------------------------------------------------------------
654 // accessors
655 // -----------------------------------------------------------------------------
656
657 size_t wxTreeCtrl::GetCount() const
658 {
659 return m_anchor == NULL ? 0u : m_anchor->GetChildrenCount();
660 }
661
662 void wxTreeCtrl::SetIndent(unsigned int indent)
663 {
664 m_indent = indent;
665 m_dirty = TRUE;
666 }
667
668 void wxTreeCtrl::SetSpacing(unsigned int spacing)
669 {
670 m_spacing = spacing;
671 m_dirty = TRUE;
672 }
673
674 size_t wxTreeCtrl::GetChildrenCount(const wxTreeItemId& item, bool recursively)
675 {
676 wxCHECK_MSG( item.IsOk(), 0u, wxT("invalid tree item") );
677
678 return item.m_pItem->GetChildrenCount(recursively);
679 }
680
681 // -----------------------------------------------------------------------------
682 // functions to work with tree items
683 // -----------------------------------------------------------------------------
684
685 wxString wxTreeCtrl::GetItemText(const wxTreeItemId& item) const
686 {
687 wxCHECK_MSG( item.IsOk(), wxT(""), wxT("invalid tree item") );
688
689 return item.m_pItem->GetText();
690 }
691
692 int wxTreeCtrl::GetItemImage(const wxTreeItemId& item,
693 wxTreeItemIcon which) const
694 {
695 wxCHECK_MSG( item.IsOk(), -1, wxT("invalid tree item") );
696
697 return item.m_pItem->GetImage(which);
698 }
699
700 wxTreeItemData *wxTreeCtrl::GetItemData(const wxTreeItemId& item) const
701 {
702 wxCHECK_MSG( item.IsOk(), NULL, wxT("invalid tree item") );
703
704 return item.m_pItem->GetData();
705 }
706
707 void wxTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text)
708 {
709 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
710
711 wxClientDC dc(this);
712 wxGenericTreeItem *pItem = item.m_pItem;
713 pItem->SetText(text);
714 CalculateSize(pItem, dc);
715 RefreshLine(pItem);
716 }
717
718 void wxTreeCtrl::SetItemImage(const wxTreeItemId& item,
719 int image,
720 wxTreeItemIcon which)
721 {
722 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
723
724 wxGenericTreeItem *pItem = item.m_pItem;
725 pItem->SetImage(image, which);
726
727 wxClientDC dc(this);
728 CalculateSize(pItem, dc);
729 RefreshLine(pItem);
730 }
731
732 void wxTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data)
733 {
734 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
735
736 item.m_pItem->SetData(data);
737 }
738
739 void wxTreeCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
740 {
741 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
742
743 wxGenericTreeItem *pItem = item.m_pItem;
744 pItem->SetHasPlus(has);
745 RefreshLine(pItem);
746 }
747
748 void wxTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
749 {
750 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
751
752 // avoid redrawing the tree if no real change
753 wxGenericTreeItem *pItem = item.m_pItem;
754 if ( pItem->IsBold() != bold )
755 {
756 pItem->SetBold(bold);
757 RefreshLine(pItem);
758 }
759 }
760
761 void wxTreeCtrl::SetItemTextColour(const wxTreeItemId& item,
762 const wxColour& col)
763 {
764 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
765
766 wxGenericTreeItem *pItem = item.m_pItem;
767 pItem->Attr().SetTextColour(col);
768 RefreshLine(pItem);
769 }
770
771 void wxTreeCtrl::SetItemBackgroundColour(const wxTreeItemId& item,
772 const wxColour& col)
773 {
774 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
775
776 wxGenericTreeItem *pItem = item.m_pItem;
777 pItem->Attr().SetBackgroundColour(col);
778 RefreshLine(pItem);
779 }
780
781 void wxTreeCtrl::SetItemFont(const wxTreeItemId& item, const wxFont& font)
782 {
783 wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
784
785 wxGenericTreeItem *pItem = item.m_pItem;
786 pItem->Attr().SetFont(font);
787 RefreshLine(pItem);
788 }
789
790 // -----------------------------------------------------------------------------
791 // item status inquiries
792 // -----------------------------------------------------------------------------
793
794 bool wxTreeCtrl::IsVisible(const wxTreeItemId& WXUNUSED(item)) const
795 {
796 wxFAIL_MSG(wxT("not implemented"));
797
798 return TRUE;
799 }
800
801 bool wxTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const
802 {
803 wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
804
805 return !item.m_pItem->GetChildren().IsEmpty();
806 }
807
808 bool wxTreeCtrl::IsExpanded(const wxTreeItemId& item) const
809 {
810 wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
811
812 return item.m_pItem->IsExpanded();
813 }
814
815 bool wxTreeCtrl::IsSelected(const wxTreeItemId& item) const
816 {
817 wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
818
819 return item.m_pItem->IsSelected();
820 }
821
822 bool wxTreeCtrl::IsBold(const wxTreeItemId& item) const
823 {
824 wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
825
826 return item.m_pItem->IsBold();
827 }
828
829 // -----------------------------------------------------------------------------
830 // navigation
831 // -----------------------------------------------------------------------------
832
833 wxTreeItemId wxTreeCtrl::GetParent(const wxTreeItemId& item) const
834 {
835 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
836
837 return item.m_pItem->GetParent();
838 }
839
840 wxTreeItemId wxTreeCtrl::GetFirstChild(const wxTreeItemId& item, long& cookie) const
841 {
842 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
843
844 cookie = 0;
845 return GetNextChild(item, cookie);
846 }
847
848 wxTreeItemId wxTreeCtrl::GetNextChild(const wxTreeItemId& item, long& cookie) const
849 {
850 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
851
852 wxArrayGenericTreeItems& children = item.m_pItem->GetChildren();
853 if ( (size_t)cookie < children.Count() )
854 {
855 return children.Item((size_t)cookie++);
856 }
857 else
858 {
859 // there are no more of them
860 return wxTreeItemId();
861 }
862 }
863
864 wxTreeItemId wxTreeCtrl::GetLastChild(const wxTreeItemId& item) const
865 {
866 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
867
868 wxArrayGenericTreeItems& children = item.m_pItem->GetChildren();
869 return (children.IsEmpty() ? wxTreeItemId() : wxTreeItemId(children.Last()));
870 }
871
872 wxTreeItemId wxTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
873 {
874 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
875
876 wxGenericTreeItem *i = item.m_pItem;
877 wxGenericTreeItem *parent = i->GetParent();
878 if ( parent == NULL )
879 {
880 // root item doesn't have any siblings
881 return wxTreeItemId();
882 }
883
884 wxArrayGenericTreeItems& siblings = parent->GetChildren();
885 int index = siblings.Index(i);
886 wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
887
888 size_t n = (size_t)(index + 1);
889 return n == siblings.Count() ? wxTreeItemId() : wxTreeItemId(siblings[n]);
890 }
891
892 wxTreeItemId wxTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const
893 {
894 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
895
896 wxGenericTreeItem *i = item.m_pItem;
897 wxGenericTreeItem *parent = i->GetParent();
898 if ( parent == NULL )
899 {
900 // root item doesn't have any siblings
901 return wxTreeItemId();
902 }
903
904 wxArrayGenericTreeItems& siblings = parent->GetChildren();
905 int index = siblings.Index(i);
906 wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
907
908 return index == 0 ? wxTreeItemId()
909 : wxTreeItemId(siblings[(size_t)(index - 1)]);
910 }
911
912 wxTreeItemId wxTreeCtrl::GetFirstVisibleItem() const
913 {
914 wxFAIL_MSG(wxT("not implemented"));
915
916 return wxTreeItemId();
917 }
918
919 wxTreeItemId wxTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
920 {
921 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
922
923 wxFAIL_MSG(wxT("not implemented"));
924
925 return wxTreeItemId();
926 }
927
928 wxTreeItemId wxTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
929 {
930 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
931
932 wxFAIL_MSG(wxT("not implemented"));
933
934 return wxTreeItemId();
935 }
936
937 // -----------------------------------------------------------------------------
938 // operations
939 // -----------------------------------------------------------------------------
940
941 wxTreeItemId wxTreeCtrl::DoInsertItem(const wxTreeItemId& parentId,
942 size_t previous,
943 const wxString& text,
944 int image, int selImage,
945 wxTreeItemData *data)
946 {
947 wxGenericTreeItem *parent = parentId.m_pItem;
948 if ( !parent )
949 {
950 // should we give a warning here?
951 return AddRoot(text, image, selImage, data);
952 }
953
954 wxClientDC dc(this);
955 wxGenericTreeItem *item =
956 new wxGenericTreeItem( parent, text, dc, image, selImage, data );
957
958 if ( data != NULL )
959 {
960 data->m_pItem = item;
961 }
962
963 parent->Insert( item, previous );
964
965 m_dirty = TRUE;
966
967 return item;
968 }
969
970 wxTreeItemId wxTreeCtrl::AddRoot(const wxString& text,
971 int image, int selImage,
972 wxTreeItemData *data)
973 {
974 wxCHECK_MSG( !m_anchor, wxTreeItemId(), wxT("tree can have only one root") );
975
976 wxClientDC dc(this);
977 m_anchor = new wxGenericTreeItem((wxGenericTreeItem *)NULL, text, dc,
978 image, selImage, data);
979 if ( data != NULL )
980 {
981 data->m_pItem = m_anchor;
982 }
983
984 if (!HasFlag(wxTR_MULTIPLE))
985 {
986 m_current = m_key_current = m_anchor;
987 m_current->SetHilight( TRUE );
988 }
989
990 Refresh();
991 AdjustMyScrollbars();
992
993 return m_anchor;
994 }
995
996 wxTreeItemId wxTreeCtrl::PrependItem(const wxTreeItemId& parent,
997 const wxString& text,
998 int image, int selImage,
999 wxTreeItemData *data)
1000 {
1001 return DoInsertItem(parent, 0u, text, image, selImage, data);
1002 }
1003
1004 wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parentId,
1005 const wxTreeItemId& idPrevious,
1006 const wxString& text,
1007 int image, int selImage,
1008 wxTreeItemData *data)
1009 {
1010 wxGenericTreeItem *parent = parentId.m_pItem;
1011 if ( !parent )
1012 {
1013 // should we give a warning here?
1014 return AddRoot(text, image, selImage, data);
1015 }
1016
1017 int index = parent->GetChildren().Index(idPrevious.m_pItem);
1018 wxASSERT_MSG( index != wxNOT_FOUND,
1019 wxT("previous item in wxTreeCtrl::InsertItem() is not a sibling") );
1020
1021 return DoInsertItem(parentId, (size_t)++index, text, image, selImage, data);
1022 }
1023
1024 wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parentId,
1025 size_t before,
1026 const wxString& text,
1027 int image, int selImage,
1028 wxTreeItemData *data)
1029 {
1030 wxGenericTreeItem *parent = parentId.m_pItem;
1031 if ( !parent )
1032 {
1033 // should we give a warning here?
1034 return AddRoot(text, image, selImage, data);
1035 }
1036
1037 return DoInsertItem(parentId, before, text, image, selImage, data);
1038 }
1039
1040 wxTreeItemId wxTreeCtrl::AppendItem(const wxTreeItemId& parentId,
1041 const wxString& text,
1042 int image, int selImage,
1043 wxTreeItemData *data)
1044 {
1045 wxGenericTreeItem *parent = parentId.m_pItem;
1046 if ( !parent )
1047 {
1048 // should we give a warning here?
1049 return AddRoot(text, image, selImage, data);
1050 }
1051
1052 return DoInsertItem( parent, parent->GetChildren().Count(), text,
1053 image, selImage, data);
1054 }
1055
1056 void wxTreeCtrl::SendDeleteEvent(wxGenericTreeItem *item)
1057 {
1058 wxTreeEvent event( wxEVT_COMMAND_TREE_DELETE_ITEM, GetId() );
1059 event.m_item = item;
1060 event.SetEventObject( this );
1061 ProcessEvent( event );
1062 }
1063
1064 void wxTreeCtrl::DeleteChildren(const wxTreeItemId& itemId)
1065 {
1066 wxGenericTreeItem *item = itemId.m_pItem;
1067 item->DeleteChildren(this);
1068
1069 m_dirty = TRUE;
1070 }
1071
1072 void wxTreeCtrl::Delete(const wxTreeItemId& itemId)
1073 {
1074 wxGenericTreeItem *item = itemId.m_pItem;
1075 wxGenericTreeItem *parent = item->GetParent();
1076
1077 if ( parent )
1078 {
1079 parent->GetChildren().Remove( item ); // remove by value
1080 }
1081
1082 item->DeleteChildren(this);
1083 SendDeleteEvent(item);
1084 delete item;
1085
1086 m_dirty = TRUE;
1087 }
1088
1089 void wxTreeCtrl::DeleteAllItems()
1090 {
1091 if ( m_anchor )
1092 {
1093 m_anchor->DeleteChildren(this);
1094 delete m_anchor;
1095
1096 m_anchor = NULL;
1097
1098 m_dirty = TRUE;
1099 }
1100 }
1101
1102 void wxTreeCtrl::Expand(const wxTreeItemId& itemId)
1103 {
1104 wxGenericTreeItem *item = itemId.m_pItem;
1105
1106 if ( !item->HasPlus() )
1107 return;
1108
1109 if ( item->IsExpanded() )
1110 return;
1111
1112 wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_EXPANDING, GetId() );
1113 event.m_item = item;
1114 event.SetEventObject( this );
1115
1116 // if ( ProcessEvent( event ) && event.m_code ) TODO: Was this a typo ?
1117 if ( ProcessEvent( event ) && !event.IsAllowed() )
1118 {
1119 // cancelled by program
1120 return;
1121 }
1122
1123 item->Expand();
1124 CalculatePositions();
1125
1126 RefreshSubtree(item);
1127
1128 event.SetEventType(wxEVT_COMMAND_TREE_ITEM_EXPANDED);
1129 ProcessEvent( event );
1130 }
1131
1132 void wxTreeCtrl::Collapse(const wxTreeItemId& itemId)
1133 {
1134 wxGenericTreeItem *item = itemId.m_pItem;
1135
1136 if ( !item->IsExpanded() )
1137 return;
1138
1139 wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_COLLAPSING, GetId() );
1140 event.m_item = item;
1141 event.SetEventObject( this );
1142 if ( ProcessEvent( event ) && !event.IsAllowed() )
1143 {
1144 // cancelled by program
1145 return;
1146 }
1147
1148 item->Collapse();
1149
1150 wxArrayGenericTreeItems& children = item->GetChildren();
1151 size_t count = children.Count();
1152 for ( size_t n = 0; n < count; n++ )
1153 {
1154 Collapse(children[n]);
1155 }
1156
1157 CalculatePositions();
1158
1159 RefreshSubtree(item);
1160
1161 event.SetEventType(wxEVT_COMMAND_TREE_ITEM_COLLAPSED);
1162 ProcessEvent( event );
1163 }
1164
1165 void wxTreeCtrl::CollapseAndReset(const wxTreeItemId& item)
1166 {
1167 Collapse(item);
1168 DeleteChildren(item);
1169 }
1170
1171 void wxTreeCtrl::Toggle(const wxTreeItemId& itemId)
1172 {
1173 wxGenericTreeItem *item = itemId.m_pItem;
1174
1175 if (item->IsExpanded())
1176 Collapse(itemId);
1177 else
1178 Expand(itemId);
1179 }
1180
1181 void wxTreeCtrl::Unselect()
1182 {
1183 if (m_current)
1184 {
1185 m_current->SetHilight( FALSE );
1186 RefreshLine( m_current );
1187 }
1188 }
1189
1190 void wxTreeCtrl::UnselectAllChildren(wxGenericTreeItem *item)
1191 {
1192 if (item->IsSelected())
1193 {
1194 item->SetHilight(FALSE);
1195 RefreshLine(item);
1196 }
1197
1198 if (item->HasChildren())
1199 {
1200 wxArrayGenericTreeItems& children = item->GetChildren();
1201 size_t count = children.Count();
1202 for ( size_t n = 0; n < count; ++n )
1203 {
1204 UnselectAllChildren(children[n]);
1205 }
1206 }
1207 }
1208
1209 void wxTreeCtrl::UnselectAll()
1210 {
1211 UnselectAllChildren(GetRootItem().m_pItem);
1212 }
1213
1214 // Recursive function !
1215 // To stop we must have crt_item<last_item
1216 // Algorithm :
1217 // Tag all next children, when no more children,
1218 // Move to parent (not to tag)
1219 // Keep going... if we found last_item, we stop.
1220 bool wxTreeCtrl::TagNextChildren(wxGenericTreeItem *crt_item, wxGenericTreeItem *last_item, bool select)
1221 {
1222 wxGenericTreeItem *parent = crt_item->GetParent();
1223
1224 if (parent == NULL) // This is root item
1225 return TagAllChildrenUntilLast(crt_item, last_item, select);
1226
1227 wxArrayGenericTreeItems& children = parent->GetChildren();
1228 int index = children.Index(crt_item);
1229 wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
1230
1231 size_t count = children.Count();
1232 for (size_t n=(size_t)(index+1); n<count; ++n)
1233 {
1234 if (TagAllChildrenUntilLast(children[n], last_item, select)) return TRUE;
1235 }
1236
1237 return TagNextChildren(parent, last_item, select);
1238 }
1239
1240 bool wxTreeCtrl::TagAllChildrenUntilLast(wxGenericTreeItem *crt_item, wxGenericTreeItem *last_item, bool select)
1241 {
1242 crt_item->SetHilight(select);
1243 RefreshLine(crt_item);
1244
1245 if (crt_item==last_item)
1246 return TRUE;
1247
1248 if (crt_item->HasChildren())
1249 {
1250 wxArrayGenericTreeItems& children = crt_item->GetChildren();
1251 size_t count = children.Count();
1252 for ( size_t n = 0; n < count; ++n )
1253 {
1254 if (TagAllChildrenUntilLast(children[n], last_item, select))
1255 return TRUE;
1256 }
1257 }
1258
1259 return FALSE;
1260 }
1261
1262 void wxTreeCtrl::SelectItemRange(wxGenericTreeItem *item1, wxGenericTreeItem *item2)
1263 {
1264 // item2 is not necessary after item1
1265 wxGenericTreeItem *first=NULL, *last=NULL;
1266
1267 // choice first' and 'last' between item1 and item2
1268 if (item1->GetY()<item2->GetY())
1269 {
1270 first=item1;
1271 last=item2;
1272 }
1273 else
1274 {
1275 first=item2;
1276 last=item1;
1277 }
1278
1279 bool select = m_current->IsSelected();
1280
1281 if ( TagAllChildrenUntilLast(first,last,select) )
1282 return;
1283
1284 TagNextChildren(first,last,select);
1285 }
1286
1287 void wxTreeCtrl::SelectItem(const wxTreeItemId& itemId,
1288 bool unselect_others,
1289 bool extended_select)
1290 {
1291 wxCHECK_RET( itemId.IsOk(), wxT("invalid tree item") );
1292
1293 bool is_single=!(GetWindowStyleFlag() & wxTR_MULTIPLE);
1294 wxGenericTreeItem *item = itemId.m_pItem;
1295
1296 //wxCHECK_RET( ( (!unselect_others) && is_single),
1297 // wxT("this is a single selection tree") );
1298
1299 // to keep going anyhow !!!
1300 if (is_single)
1301 {
1302 if (item->IsSelected())
1303 return; // nothing to do
1304 unselect_others = TRUE;
1305 extended_select = FALSE;
1306 }
1307 else if ( unselect_others && item->IsSelected() )
1308 {
1309 // selection change if there is more than one item currently selected
1310 wxArrayTreeItemIds selected_items;
1311 if ( GetSelections(selected_items) == 1 )
1312 return;
1313 }
1314
1315 wxTreeEvent event( wxEVT_COMMAND_TREE_SEL_CHANGING, GetId() );
1316 event.m_item = item;
1317 event.m_itemOld = m_current;
1318 event.SetEventObject( this );
1319 // TODO : Here we don't send any selection mode yet !
1320
1321 if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() )
1322 return;
1323
1324 // ctrl press
1325 if (unselect_others)
1326 {
1327 if (is_single) Unselect(); // to speed up thing
1328 else UnselectAll();
1329 }
1330
1331 // shift press
1332 if (extended_select)
1333 {
1334 if (m_current == NULL) m_current=m_key_current=GetRootItem().m_pItem;
1335 // don't change the mark (m_current)
1336 SelectItemRange(m_current, item);
1337 }
1338 else
1339 {
1340 bool select=TRUE; // the default
1341
1342 // Check if we need to toggle hilight (ctrl mode)
1343 if (!unselect_others)
1344 select=!item->IsSelected();
1345
1346 m_current = m_key_current = item;
1347 m_current->SetHilight(select);
1348 RefreshLine( m_current );
1349 }
1350
1351 event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
1352 GetEventHandler()->ProcessEvent( event );
1353 }
1354
1355 void wxTreeCtrl::FillArray(wxGenericTreeItem *item,
1356 wxArrayTreeItemIds &array) const
1357 {
1358 if ( item->IsSelected() )
1359 array.Add(wxTreeItemId(item));
1360
1361 if ( item->HasChildren() )
1362 {
1363 wxArrayGenericTreeItems& children = item->GetChildren();
1364 size_t count = children.GetCount();
1365 for ( size_t n = 0; n < count; ++n )
1366 FillArray(children[n],array);
1367 }
1368 }
1369
1370 size_t wxTreeCtrl::GetSelections(wxArrayTreeItemIds &array) const
1371 {
1372 array.Empty();
1373 FillArray(GetRootItem().m_pItem, array);
1374
1375 return array.Count();
1376 }
1377
1378 void wxTreeCtrl::EnsureVisible(const wxTreeItemId& item)
1379 {
1380 if (!item.IsOk()) return;
1381
1382 wxGenericTreeItem *gitem = item.m_pItem;
1383
1384 // first expand all parent branches
1385 wxGenericTreeItem *parent = gitem->GetParent();
1386 while ( parent )
1387 {
1388 Expand(parent);
1389 parent = parent->GetParent();
1390 }
1391
1392 //if (parent) CalculatePositions();
1393
1394 ScrollTo(item);
1395 }
1396
1397 void wxTreeCtrl::ScrollTo(const wxTreeItemId &item)
1398 {
1399 if (!item.IsOk()) return;
1400
1401 // We have to call this here because the label in
1402 // question might just have been added and no screen
1403 // update taken place.
1404 if (m_dirty) wxYield();
1405
1406 wxGenericTreeItem *gitem = item.m_pItem;
1407
1408 // now scroll to the item
1409 int item_y = gitem->GetY();
1410
1411 int start_x = 0;
1412 int start_y = 0;
1413 ViewStart( &start_x, &start_y );
1414 start_y *= PIXELS_PER_UNIT;
1415
1416 int client_h = 0;
1417 int client_w = 0;
1418 GetClientSize( &client_w, &client_h );
1419
1420 if (item_y < start_y+3)
1421 {
1422 // going down
1423 int x = 0;
1424 int y = 0;
1425 m_anchor->GetSize( x, y, this );
1426 y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1427 x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1428 int x_pos = GetScrollPos( wxHORIZONTAL );
1429 // Item should appear at top
1430 SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, item_y/PIXELS_PER_UNIT );
1431 }
1432 else if (item_y+GetLineHeight(gitem) > start_y+client_h)
1433 {
1434 // going up
1435 int x = 0;
1436 int y = 0;
1437 m_anchor->GetSize( x, y, this );
1438 y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1439 x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1440 item_y += PIXELS_PER_UNIT+2;
1441 int x_pos = GetScrollPos( wxHORIZONTAL );
1442 // Item should appear at bottom
1443 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 );
1444 }
1445 }
1446
1447 // FIXME: tree sorting functions are not reentrant and not MT-safe!
1448 static wxTreeCtrl *s_treeBeingSorted = NULL;
1449
1450 static int LINKAGEMODE tree_ctrl_compare_func(wxGenericTreeItem **item1,
1451 wxGenericTreeItem **item2)
1452 {
1453 wxCHECK_MSG( s_treeBeingSorted, 0, wxT("bug in wxTreeCtrl::SortChildren()") );
1454
1455 return s_treeBeingSorted->OnCompareItems(*item1, *item2);
1456 }
1457
1458 int wxTreeCtrl::OnCompareItems(const wxTreeItemId& item1,
1459 const wxTreeItemId& item2)
1460 {
1461 return wxStrcmp(GetItemText(item1), GetItemText(item2));
1462 }
1463
1464 void wxTreeCtrl::SortChildren(const wxTreeItemId& itemId)
1465 {
1466 wxCHECK_RET( itemId.IsOk(), wxT("invalid tree item") );
1467
1468 wxGenericTreeItem *item = itemId.m_pItem;
1469
1470 wxCHECK_RET( !s_treeBeingSorted,
1471 wxT("wxTreeCtrl::SortChildren is not reentrant") );
1472
1473 wxArrayGenericTreeItems& children = item->GetChildren();
1474 if ( children.Count() > 1 )
1475 {
1476 s_treeBeingSorted = this;
1477 children.Sort(tree_ctrl_compare_func);
1478 s_treeBeingSorted = NULL;
1479
1480 m_dirty = TRUE;
1481 }
1482 //else: don't make the tree dirty as nothing changed
1483 }
1484
1485 wxImageList *wxTreeCtrl::GetImageList() const
1486 {
1487 return m_imageListNormal;
1488 }
1489
1490 wxImageList *wxTreeCtrl::GetStateImageList() const
1491 {
1492 return m_imageListState;
1493 }
1494
1495 void wxTreeCtrl::SetImageList(wxImageList *imageList)
1496 {
1497 m_imageListNormal = imageList;
1498
1499 // Calculate a m_lineHeight value from the image sizes.
1500 // May be toggle off. Then wxTreeCtrl will spread when
1501 // necessary (which might look ugly).
1502 #if 1
1503 wxClientDC dc(this);
1504 m_lineHeight = (int)(dc.GetCharHeight() + 4);
1505 int width = 0, height = 0,
1506 n = m_imageListNormal->GetImageCount();
1507
1508 for (int i = 0; i < n ; i++)
1509 {
1510 m_imageListNormal->GetSize(i, width, height);
1511 if (height > m_lineHeight) m_lineHeight = height;
1512 }
1513
1514 if (m_lineHeight < 40)
1515 m_lineHeight += 2; // at least 2 pixels
1516 else
1517 m_lineHeight += m_lineHeight/10; // otherwise 10% extra spacing
1518 #endif
1519 }
1520
1521 void wxTreeCtrl::SetStateImageList(wxImageList *imageList)
1522 {
1523 m_imageListState = imageList;
1524 }
1525
1526 // -----------------------------------------------------------------------------
1527 // helpers
1528 // -----------------------------------------------------------------------------
1529
1530 void wxTreeCtrl::AdjustMyScrollbars()
1531 {
1532 if (m_anchor)
1533 {
1534 int x = 0;
1535 int y = 0;
1536 m_anchor->GetSize( x, y, this );
1537 y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1538 x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1539 int x_pos = GetScrollPos( wxHORIZONTAL );
1540 int y_pos = GetScrollPos( wxVERTICAL );
1541 SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, y_pos );
1542 }
1543 else
1544 {
1545 SetScrollbars( 0, 0, 0, 0 );
1546 }
1547 }
1548
1549 int wxTreeCtrl::GetLineHeight(wxGenericTreeItem *item) const
1550 {
1551 if (GetWindowStyleFlag() & wxTR_HAS_VARIABLE_ROW_HEIGHT)
1552 return item->GetHeight();
1553 else
1554 return m_lineHeight;
1555 }
1556
1557 void wxTreeCtrl::PaintItem(wxGenericTreeItem *item, wxDC& dc)
1558 {
1559 wxTreeItemAttr *attr = item->GetAttributes();
1560 if ( attr && attr->HasFont() )
1561 dc.SetFont(attr->GetFont());
1562 else if (item->IsBold())
1563 dc.SetFont(m_boldFont);
1564
1565 long text_w = 0;
1566 long text_h = 0;
1567 dc.GetTextExtent( item->GetText(), &text_w, &text_h );
1568
1569 int image_h = 0;
1570 int image_w = 0;
1571 int image = item->GetCurrentImage();
1572 if ( image != NO_IMAGE )
1573 {
1574 m_imageListNormal->GetSize( image, image_w, image_h );
1575 image_w += 4;
1576 }
1577
1578 int total_h = GetLineHeight(item);
1579
1580 if (item->IsSelected())
1581 dc.SetBrush(*m_hilightBrush);
1582 else
1583 {
1584 wxColour colBg;
1585 if ( attr && attr->HasBackgroundColour() )
1586 colBg = attr->GetBackgroundColour();
1587 else
1588 colBg = m_backgroundColour;
1589 dc.SetBrush(wxBrush(colBg, wxSOLID));
1590 }
1591
1592 dc.DrawRectangle( item->GetX()-2, item->GetY(), item->GetWidth()+2, total_h );
1593
1594 if ( image != NO_IMAGE )
1595 {
1596 dc.SetClippingRegion( item->GetX(), item->GetY(), image_w-2, total_h );
1597 m_imageListNormal->Draw( image, dc,
1598 item->GetX(),
1599 item->GetY() +((total_h > image_h)?((total_h-image_h)/2):0),
1600 wxIMAGELIST_DRAW_TRANSPARENT );
1601 dc.DestroyClippingRegion();
1602 }
1603
1604 dc.SetBackgroundMode(wxTRANSPARENT);
1605 dc.DrawText( item->GetText(), image_w + item->GetX(), (wxCoord)item->GetY()
1606 + ((total_h > text_h) ? (total_h - text_h)/2 : 0));
1607
1608 // restore normal font
1609 dc.SetFont( m_normalFont );
1610 }
1611
1612 // Now y stands for the top of the item, whereas it used to stand for middle !
1613 void wxTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y )
1614 {
1615 int horizX = level*m_indent;
1616
1617 item->SetX( horizX+m_indent+m_spacing );
1618 item->SetY( y );
1619
1620 int oldY = y;
1621 y+=GetLineHeight(item)/2;
1622
1623 item->SetCross( horizX+m_indent, y );
1624
1625 int exposed_x = dc.LogicalToDeviceX( 0 );
1626 int exposed_y = dc.LogicalToDeviceY( item->GetY() );
1627
1628 if (IsExposed( exposed_x, exposed_y, 10000, GetLineHeight(item) )) // 10000 = very much
1629 {
1630 int startX = horizX;
1631 int endX = horizX + (m_indent-5);
1632
1633 // if (!item->HasChildren()) endX += (m_indent+5);
1634 if (!item->HasChildren()) endX += 20;
1635
1636 dc.DrawLine( startX, y, endX, y );
1637
1638 if (item->HasPlus())
1639 {
1640 dc.DrawLine( horizX+(m_indent+5), y, horizX+(m_indent+15), y );
1641 dc.SetPen( *wxGREY_PEN );
1642 dc.SetBrush( *wxWHITE_BRUSH );
1643 dc.DrawRectangle( horizX+(m_indent-5), y-4, 11, 9 );
1644
1645 dc.SetPen( *wxBLACK_PEN );
1646 dc.DrawLine( horizX+(m_indent-2), y, horizX+(m_indent+3), y );
1647 if (!item->IsExpanded())
1648 dc.DrawLine( horizX+m_indent, y-2, horizX+m_indent, y+3 );
1649
1650 dc.SetPen( m_dottedPen );
1651 }
1652
1653 wxPen *pen = wxTRANSPARENT_PEN;
1654 wxColour colText;
1655
1656 if ( item->IsSelected() )
1657 {
1658 colText = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_HIGHLIGHTTEXT );
1659
1660 if ( m_hasFocus )
1661 pen = wxBLACK_PEN;
1662
1663 }
1664 else
1665 {
1666 wxTreeItemAttr *attr = item->GetAttributes();
1667 if ( attr && attr->HasTextColour() )
1668 colText = attr->GetTextColour();
1669 else
1670 colText = *wxBLACK;
1671 }
1672
1673 // prepare to draw
1674 dc.SetTextForeground(colText);
1675 dc.SetPen(*pen);
1676
1677 // draw
1678 PaintItem(item, dc);
1679
1680 // restore DC objects
1681 dc.SetBrush( *wxWHITE_BRUSH );
1682 dc.SetPen( m_dottedPen );
1683 dc.SetTextForeground( *wxBLACK );
1684 }
1685
1686 y = oldY+GetLineHeight(item);
1687
1688 if (item->IsExpanded())
1689 {
1690 oldY+=GetLineHeight(item)/2;
1691 int semiOldY=0;
1692
1693 wxArrayGenericTreeItems& children = item->GetChildren();
1694 size_t n, count = children.Count();
1695 for ( n = 0; n < count; ++n )
1696 {
1697 semiOldY=y;
1698 PaintLevel( children[n], dc, level+1, y );
1699 }
1700
1701 // it may happen that the item is expanded but has no items (when you
1702 // delete all its children for example) - don't draw the vertical line
1703 // in this case
1704 if (count > 0)
1705 {
1706 semiOldY+=GetLineHeight(children[--n])/2;
1707 dc.DrawLine( horizX+m_indent, oldY+5, horizX+m_indent, semiOldY );
1708 }
1709 }
1710 }
1711
1712 void wxTreeCtrl::DrawDropEffect(wxGenericTreeItem *item)
1713 {
1714 if ( item )
1715 {
1716 if ( item->HasPlus() )
1717 {
1718 // it's a folder, indicate it by a border
1719 DrawBorder(item);
1720 }
1721 else
1722 {
1723 // draw a line under the drop target because the item will be
1724 // dropped there
1725 DrawLine(item, TRUE /* below */);
1726 }
1727
1728 SetCursor(wxCURSOR_BULLSEYE);
1729 }
1730 else
1731 {
1732 // can't drop here
1733 SetCursor(wxCURSOR_NO_ENTRY);
1734 }
1735 }
1736
1737 void wxTreeCtrl::DrawBorder(const wxTreeItemId &item)
1738 {
1739 wxCHECK_RET( item.IsOk(), _T("invalid item in wxTreeCtrl::DrawLine") );
1740
1741 wxGenericTreeItem *i = item.m_pItem;
1742
1743 wxClientDC dc(this);
1744 PrepareDC( dc );
1745 dc.SetLogicalFunction(wxINVERT);
1746 dc.SetBrush(*wxTRANSPARENT_BRUSH);
1747
1748 int w = i->GetWidth() + 2;
1749 int h = GetLineHeight(i) + 2;
1750
1751 dc.DrawRectangle( i->GetX() - 1, i->GetY() - 1, w, h);
1752 }
1753
1754 void wxTreeCtrl::DrawLine(const wxTreeItemId &item, bool below)
1755 {
1756 wxCHECK_RET( item.IsOk(), _T("invalid item in wxTreeCtrl::DrawLine") );
1757
1758 wxGenericTreeItem *i = item.m_pItem;
1759
1760 wxClientDC dc(this);
1761 PrepareDC( dc );
1762 dc.SetLogicalFunction(wxINVERT);
1763
1764 int x = i->GetX(),
1765 y = i->GetY();
1766 if ( below )
1767 {
1768 y += GetLineHeight(i) - 1;
1769 }
1770
1771 dc.DrawLine( x, y, x + i->GetWidth(), y);
1772 }
1773
1774 // -----------------------------------------------------------------------------
1775 // wxWindows callbacks
1776 // -----------------------------------------------------------------------------
1777
1778 void wxTreeCtrl::OnPaint( wxPaintEvent &WXUNUSED(event) )
1779 {
1780 if ( !m_anchor)
1781 return;
1782
1783 wxPaintDC dc(this);
1784 PrepareDC( dc );
1785
1786 dc.SetFont( m_normalFont );
1787 dc.SetPen( m_dottedPen );
1788
1789 // this is now done dynamically
1790 //if(GetImageList() == NULL)
1791 // m_lineHeight = (int)(dc.GetCharHeight() + 4);
1792
1793 int y = 2;
1794 PaintLevel( m_anchor, dc, 0, y );
1795 }
1796
1797 void wxTreeCtrl::OnSetFocus( wxFocusEvent &WXUNUSED(event) )
1798 {
1799 m_hasFocus = TRUE;
1800
1801 if (m_current) RefreshLine( m_current );
1802 }
1803
1804 void wxTreeCtrl::OnKillFocus( wxFocusEvent &WXUNUSED(event) )
1805 {
1806 m_hasFocus = FALSE;
1807
1808 if (m_current) RefreshLine( m_current );
1809 }
1810
1811 void wxTreeCtrl::OnChar( wxKeyEvent &event )
1812 {
1813 wxTreeEvent te( wxEVT_COMMAND_TREE_KEY_DOWN, GetId() );
1814 te.m_code = (int)event.KeyCode();
1815 te.SetEventObject( this );
1816 GetEventHandler()->ProcessEvent( te );
1817
1818 if ( (m_current == 0) || (m_key_current == 0) )
1819 {
1820 event.Skip();
1821 return;
1822 }
1823
1824 // how should the selection work for this event?
1825 bool is_multiple, extended_select, unselect_others;
1826 EventFlagsToSelType(GetWindowStyleFlag(),
1827 event.ShiftDown(),
1828 event.ControlDown(),
1829 &is_multiple, &extended_select, &unselect_others);
1830
1831 switch (event.KeyCode())
1832 {
1833 case '+':
1834 case WXK_ADD:
1835 if (m_current->HasPlus() && !IsExpanded(m_current))
1836 {
1837 Expand(m_current);
1838 }
1839 break;
1840
1841 case '-':
1842 case WXK_SUBTRACT:
1843 if (IsExpanded(m_current))
1844 {
1845 Collapse(m_current);
1846 }
1847 break;
1848
1849 case '*':
1850 case WXK_MULTIPLY:
1851 Toggle(m_current);
1852 break;
1853
1854 case ' ':
1855 case WXK_RETURN:
1856 {
1857 wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
1858 event.m_item = m_current;
1859 event.m_code = 0;
1860 event.SetEventObject( this );
1861 GetEventHandler()->ProcessEvent( event );
1862 }
1863 break;
1864
1865 // up goes to the previous sibling or to the last of its children if
1866 // it's expanded
1867 case WXK_UP:
1868 {
1869 wxTreeItemId prev = GetPrevSibling( m_key_current );
1870 if (!prev)
1871 {
1872 prev = GetParent( m_key_current );
1873 if (prev)
1874 {
1875 long cockie = 0;
1876 wxTreeItemId current = m_key_current;
1877 if (current == GetFirstChild( prev, cockie ))
1878 {
1879 // otherwise we return to where we came from
1880 SelectItem( prev, unselect_others, extended_select );
1881 m_key_current=prev.m_pItem;
1882 EnsureVisible( prev );
1883 break;
1884 }
1885 }
1886 }
1887 if (prev)
1888 {
1889 while ( IsExpanded(prev) && HasChildren(prev) )
1890 {
1891 wxTreeItemId child = GetLastChild(prev);
1892 if ( child )
1893 {
1894 prev = child;
1895 }
1896 }
1897
1898 SelectItem( prev, unselect_others, extended_select );
1899 m_key_current=prev.m_pItem;
1900 EnsureVisible( prev );
1901 }
1902 }
1903 break;
1904
1905 // left arrow goes to the parent
1906 case WXK_LEFT:
1907 {
1908 wxTreeItemId prev = GetParent( m_current );
1909 if (prev)
1910 {
1911 EnsureVisible( prev );
1912 SelectItem( prev, unselect_others, extended_select );
1913 }
1914 }
1915 break;
1916
1917 case WXK_RIGHT:
1918 // this works the same as the down arrow except that we also expand the
1919 // item if it wasn't expanded yet
1920 Expand(m_current);
1921 // fall through
1922
1923 case WXK_DOWN:
1924 {
1925 if (IsExpanded(m_key_current) && HasChildren(m_key_current))
1926 {
1927 long cookie = 0;
1928 wxTreeItemId child = GetFirstChild( m_key_current, cookie );
1929 SelectItem( child, unselect_others, extended_select );
1930 m_key_current=child.m_pItem;
1931 EnsureVisible( child );
1932 }
1933 else
1934 {
1935 wxTreeItemId next = GetNextSibling( m_key_current );
1936 // if (next == 0)
1937 if (!next)
1938 {
1939 wxTreeItemId current = m_key_current;
1940 while (current && !next)
1941 {
1942 current = GetParent( current );
1943 if (current) next = GetNextSibling( current );
1944 }
1945 }
1946 // if (next != 0)
1947 if (next)
1948 {
1949 SelectItem( next, unselect_others, extended_select );
1950 m_key_current=next.m_pItem;
1951 EnsureVisible( next );
1952 }
1953 }
1954 }
1955 break;
1956
1957 // <End> selects the last visible tree item
1958 case WXK_END:
1959 {
1960 wxTreeItemId last = GetRootItem();
1961
1962 while ( last.IsOk() && IsExpanded(last) )
1963 {
1964 wxTreeItemId lastChild = GetLastChild(last);
1965
1966 // it may happen if the item was expanded but then all of
1967 // its children have been deleted - so IsExpanded() returned
1968 // TRUE, but GetLastChild() returned invalid item
1969 if ( !lastChild )
1970 break;
1971
1972 last = lastChild;
1973 }
1974
1975 if ( last.IsOk() )
1976 {
1977 EnsureVisible( last );
1978 SelectItem( last, unselect_others, extended_select );
1979 }
1980 }
1981 break;
1982
1983 // <Home> selects the root item
1984 case WXK_HOME:
1985 {
1986 wxTreeItemId prev = GetRootItem();
1987 if (prev)
1988 {
1989 EnsureVisible( prev );
1990 SelectItem( prev, unselect_others, extended_select );
1991 }
1992 }
1993 break;
1994
1995 default:
1996 event.Skip();
1997 }
1998 }
1999
2000 wxTreeItemId wxTreeCtrl::HitTest(const wxPoint& point, int& flags)
2001 {
2002 // We have to call this here because the label in
2003 // question might just have been added and no screen
2004 // update taken place.
2005 if (m_dirty) wxYield();
2006
2007 wxClientDC dc(this);
2008 PrepareDC(dc);
2009 wxCoord x = dc.DeviceToLogicalX( point.x );
2010 wxCoord y = dc.DeviceToLogicalY( point.y );
2011 int w, h;
2012 GetSize(&w, &h);
2013
2014 flags=0;
2015 if (point.x<0) flags|=wxTREE_HITTEST_TOLEFT;
2016 if (point.x>w) flags|=wxTREE_HITTEST_TORIGHT;
2017 if (point.y<0) flags|=wxTREE_HITTEST_ABOVE;
2018 if (point.y>h) flags|=wxTREE_HITTEST_BELOW;
2019
2020 return m_anchor->HitTest( wxPoint(x, y), this, flags);
2021 }
2022
2023 /* **** */
2024
2025 void wxTreeCtrl::Edit( const wxTreeItemId& item )
2026 {
2027 if (!item.IsOk()) return;
2028
2029 m_currentEdit = item.m_pItem;
2030
2031 wxTreeEvent te( wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, GetId() );
2032 te.m_item = m_currentEdit;
2033 te.SetEventObject( this );
2034 GetEventHandler()->ProcessEvent( te );
2035
2036 if (!te.IsAllowed()) return;
2037
2038 // We have to call this here because the label in
2039 // question might just have been added and no screen
2040 // update taken place.
2041 if (m_dirty) wxYield();
2042
2043 wxString s = m_currentEdit->GetText();
2044 int x = m_currentEdit->GetX();
2045 int y = m_currentEdit->GetY();
2046 int w = m_currentEdit->GetWidth();
2047 int h = m_currentEdit->GetHeight();
2048
2049 int image_h = 0;
2050 int image_w = 0;
2051
2052 int image = m_currentEdit->GetCurrentImage();
2053 if ( image != NO_IMAGE )
2054 {
2055 m_imageListNormal->GetSize( image, image_w, image_h );
2056 image_w += 4;
2057 }
2058 x += image_w;
2059 w -= image_w + 4; // I don't know why +4 is needed
2060
2061 wxClientDC dc(this);
2062 PrepareDC( dc );
2063 x = dc.LogicalToDeviceX( x );
2064 y = dc.LogicalToDeviceY( y );
2065
2066 wxTreeTextCtrl *text = new wxTreeTextCtrl(
2067 this, -1, &m_renameAccept, &m_renameRes, this, s, wxPoint(x-4,y-4), wxSize(w+11,h+8) );
2068 text->SetFocus();
2069 }
2070
2071 void wxTreeCtrl::OnRenameTimer()
2072 {
2073 Edit( m_current );
2074 }
2075
2076 void wxTreeCtrl::OnRenameAccept()
2077 {
2078 wxTreeEvent le( wxEVT_COMMAND_TREE_END_LABEL_EDIT, GetId() );
2079 le.m_item = m_currentEdit;
2080 le.SetEventObject( this );
2081 le.m_label = m_renameRes;
2082 GetEventHandler()->ProcessEvent( le );
2083
2084 if (!le.IsAllowed()) return;
2085
2086 SetItemText( m_currentEdit, m_renameRes );
2087 }
2088
2089 void wxTreeCtrl::OnMouse( wxMouseEvent &event )
2090 {
2091 if ( !m_anchor ) return;
2092
2093 // we process left mouse up event (enables in-place edit), right down
2094 // (pass to the user code), left dbl click (activate item) and
2095 // dragging/moving events for items drag-and-drop
2096 if ( !(event.LeftUp() ||
2097 event.RightDown() ||
2098 event.LeftDClick() ||
2099 event.Dragging() ||
2100 ((event.Moving() || event.RightUp()) && m_isDragging)) )
2101 {
2102 event.Skip();
2103
2104 return;
2105 }
2106
2107 wxClientDC dc(this);
2108 PrepareDC(dc);
2109 wxCoord x = dc.DeviceToLogicalX( event.GetX() );
2110 wxCoord y = dc.DeviceToLogicalY( event.GetY() );
2111
2112 int flags = 0;
2113 wxGenericTreeItem *item = m_anchor->HitTest( wxPoint(x,y), this, flags);
2114
2115 bool onButton = flags & wxTREE_HITTEST_ONITEMBUTTON;
2116
2117 if ( event.Dragging() && !m_isDragging )
2118 {
2119 if (m_dragCount == 0)
2120 m_dragStart = wxPoint(x,y);
2121
2122 m_dragCount++;
2123
2124 if (m_dragCount != 3)
2125 {
2126 // wait until user drags a bit further...
2127 return;
2128 }
2129
2130 wxEventType command = event.RightIsDown()
2131 ? wxEVT_COMMAND_TREE_BEGIN_RDRAG
2132 : wxEVT_COMMAND_TREE_BEGIN_DRAG;
2133
2134 wxTreeEvent nevent( command, GetId() );
2135 nevent.m_item = m_current;
2136 nevent.SetEventObject(this);
2137
2138 // by default the dragging is not supported, the user code must
2139 // explicitly allow the event for it to take place
2140 nevent.Veto();
2141
2142 if ( GetEventHandler()->ProcessEvent(nevent) && nevent.IsAllowed() )
2143 {
2144 // we're going to drag this item
2145 m_isDragging = TRUE;
2146
2147 // remember the old cursor because we will change it while
2148 // dragging
2149 m_oldCursor = m_cursor;
2150
2151 // in a single selection control, hide the selection temporarily
2152 if ( !(GetWindowStyleFlag() & wxTR_MULTIPLE) )
2153 {
2154 m_oldSelection = GetSelection().m_pItem;
2155
2156 if ( m_oldSelection )
2157 {
2158 m_oldSelection->SetHilight(FALSE);
2159 RefreshLine(m_oldSelection);
2160 }
2161 }
2162
2163 CaptureMouse();
2164 }
2165 }
2166 else if ( event.Moving() )
2167 {
2168 if ( item != m_dropTarget )
2169 {
2170 // unhighlight the previous drop target
2171 DrawDropEffect(m_dropTarget);
2172
2173 m_dropTarget = item;
2174
2175 // highlight the current drop target if any
2176 DrawDropEffect(m_dropTarget);
2177
2178 wxYield();
2179 }
2180 }
2181 else if ( (event.LeftUp() || event.RightUp()) && m_isDragging )
2182 {
2183 // erase the highlighting
2184 DrawDropEffect(m_dropTarget);
2185
2186 // generate the drag end event
2187 wxTreeEvent event(wxEVT_COMMAND_TREE_END_DRAG, GetId());
2188
2189 event.m_item = item;
2190 event.m_pointDrag = wxPoint(x, y);
2191 event.SetEventObject(this);
2192
2193 (void)GetEventHandler()->ProcessEvent(event);
2194
2195 m_isDragging = FALSE;
2196 m_dropTarget = (wxGenericTreeItem *)NULL;
2197
2198 if ( m_oldSelection )
2199 {
2200 m_oldSelection->SetHilight(TRUE);
2201 RefreshLine(m_oldSelection);
2202 m_oldSelection = (wxGenericTreeItem *)NULL;
2203 }
2204
2205 ReleaseMouse();
2206
2207 SetCursor(m_oldCursor);
2208
2209 wxYield();
2210 }
2211 else
2212 {
2213 // here we process only the messages which happen on tree items
2214
2215 m_dragCount = 0;
2216
2217 if (item == NULL) return; /* we hit the blank area */
2218
2219 if ( event.RightDown() )
2220 {
2221 wxTreeEvent nevent(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK, GetId());
2222 nevent.m_item = item;
2223 nevent.m_code = 0;
2224 nevent.SetEventObject(this);
2225 GetEventHandler()->ProcessEvent(nevent);
2226 }
2227 else if ( event.LeftUp() && (item == m_current) &&
2228 (flags & wxTREE_HITTEST_ONITEMLABEL) &&
2229 HasFlag(wxTR_EDIT_LABELS) )
2230 {
2231 m_renameTimer->Start( 100, TRUE );
2232 }
2233 else
2234 {
2235 // how should the selection work for this event?
2236 bool is_multiple, extended_select, unselect_others;
2237 EventFlagsToSelType(GetWindowStyleFlag(),
2238 event.ShiftDown(),
2239 event.ControlDown(),
2240 &is_multiple, &extended_select, &unselect_others);
2241
2242 if ( onButton )
2243 {
2244 Toggle( item );
2245 if ( is_multiple )
2246 return;
2247 }
2248
2249 SelectItem(item, unselect_others, extended_select);
2250
2251 if ( event.LeftDClick() )
2252 {
2253 wxTreeEvent nevent( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
2254 nevent.m_item = item;
2255 nevent.m_code = 0;
2256 nevent.SetEventObject( this );
2257 GetEventHandler()->ProcessEvent( nevent );
2258 }
2259 }
2260 }
2261 }
2262
2263 void wxTreeCtrl::OnIdle( wxIdleEvent &WXUNUSED(event) )
2264 {
2265 /* after all changes have been done to the tree control,
2266 * we actually redraw the tree when everything is over */
2267
2268 if (!m_dirty)
2269 return;
2270
2271 m_dirty = FALSE;
2272
2273 CalculatePositions();
2274 Refresh();
2275 AdjustMyScrollbars();
2276 }
2277
2278 void wxTreeCtrl::CalculateSize( wxGenericTreeItem *item, wxDC &dc )
2279 {
2280 int text_w = 0;
2281 int text_h = 0;
2282
2283 if (item->IsBold())
2284 dc.SetFont(m_boldFont);
2285
2286 dc.GetTextExtent( item->GetText(), &text_w, &text_h );
2287 text_h+=2;
2288
2289 // restore normal font
2290 dc.SetFont( m_normalFont );
2291
2292 int image_h = 0;
2293 int image_w = 0;
2294 int image = item->GetCurrentImage();
2295 if ( image != NO_IMAGE )
2296 {
2297 m_imageListNormal->GetSize( image, image_w, image_h );
2298 image_w += 4;
2299 }
2300
2301 int total_h = (image_h > text_h) ? image_h : text_h;
2302
2303 if (total_h < 40)
2304 total_h += 2; // at least 2 pixels
2305 else
2306 total_h += total_h/10; // otherwise 10% extra spacing
2307
2308 item->SetHeight(total_h);
2309 if (total_h>m_lineHeight)
2310 m_lineHeight=total_h;
2311
2312 item->SetWidth(image_w+text_w+2);
2313 }
2314
2315 // -----------------------------------------------------------------------------
2316 // for developper : y is now the top of the level
2317 // not the middle of it !
2318 void wxTreeCtrl::CalculateLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y )
2319 {
2320 int horizX = level*m_indent;
2321
2322 CalculateSize( item, dc );
2323
2324 // set its position
2325 item->SetX( horizX+m_indent+m_spacing );
2326 item->SetY( y );
2327 y+=GetLineHeight(item);
2328
2329 if ( !item->IsExpanded() )
2330 {
2331 // we dont need to calculate collapsed branches
2332 return;
2333 }
2334
2335 wxArrayGenericTreeItems& children = item->GetChildren();
2336 size_t n, count = children.Count();
2337 for (n = 0; n < count; ++n )
2338 CalculateLevel( children[n], dc, level+1, y ); // recurse
2339 }
2340
2341 void wxTreeCtrl::CalculatePositions()
2342 {
2343 if ( !m_anchor ) return;
2344
2345 wxClientDC dc(this);
2346 PrepareDC( dc );
2347
2348 dc.SetFont( m_normalFont );
2349
2350 dc.SetPen( m_dottedPen );
2351 //if(GetImageList() == NULL)
2352 // m_lineHeight = (int)(dc.GetCharHeight() + 4);
2353
2354 int y = 2;
2355 CalculateLevel( m_anchor, dc, 0, y ); // start recursion
2356 }
2357
2358 void wxTreeCtrl::RefreshSubtree(wxGenericTreeItem *item)
2359 {
2360 if (m_dirty) return;
2361
2362 wxClientDC dc(this);
2363 PrepareDC(dc);
2364
2365 int cw = 0;
2366 int ch = 0;
2367 GetClientSize( &cw, &ch );
2368
2369 wxRect rect;
2370 rect.x = dc.LogicalToDeviceX( 0 );
2371 rect.width = cw;
2372 rect.y = dc.LogicalToDeviceY( item->GetY() );
2373 rect.height = ch;
2374
2375 Refresh( TRUE, &rect );
2376
2377 AdjustMyScrollbars();
2378 }
2379
2380 void wxTreeCtrl::RefreshLine( wxGenericTreeItem *item )
2381 {
2382 if (m_dirty) return;
2383
2384 wxClientDC dc(this);
2385 PrepareDC( dc );
2386
2387 int cw = 0;
2388 int ch = 0;
2389 GetClientSize( &cw, &ch );
2390
2391 wxRect rect;
2392 rect.x = dc.LogicalToDeviceX( 0 );
2393 rect.y = dc.LogicalToDeviceY( item->GetY() );
2394 rect.width = cw;
2395 rect.height = GetLineHeight(item); //dc.GetCharHeight() + 6;
2396
2397 Refresh( TRUE, &rect );
2398 }
2399
wxWidgets (Impactor)