]> git.saurik.com Git - wxWidgets.git/blob - src/generic/treectrl.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
splitter doesn't change position when the window containing it is minimized and restored
[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/generic/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 // private classes
52 // -----------------------------------------------------------------------------
53
54 // a tree item
55 class WXDLLEXPORT wxGenericTreeItem
56 {
57 public:
58 // ctors & dtor
59 wxGenericTreeItem() { m_data = NULL; }
60 wxGenericTreeItem( wxGenericTreeItem *parent,
61 const wxString& text,
62 wxDC& dc,
63 int image, int selImage,
64 wxTreeItemData *data );
65
66 ~wxGenericTreeItem();
67
68 // trivial accessors
69 wxArrayGenericTreeItems& GetChildren() { return m_children; }
70
71 const wxString& GetText() const { return m_text; }
72 int GetImage() const { return m_image; }
73 int GetSelectedImage() const { return m_selImage; }
74 wxTreeItemData *GetData() const { return m_data; }
75
76 void SetText( const wxString &text );
77 void SetImage(int image) { m_image = image; }
78 void SetSelectedImage(int image) { m_selImage = image; }
79 void SetData(wxTreeItemData *data) { m_data = data; }
80
81 void SetHasPlus(bool has = TRUE) { m_hasPlus = has; }
82
83 void SetBold(bool bold) { m_isBold = bold; }
84
85 int GetX() const { return m_x; }
86 int GetY() const { return m_y; }
87
88 void SetX(int x) { m_x = x; }
89 void SetY(int y) { m_y = y; }
90
91 int GetHeight() const { return m_height; }
92 int GetWidth() const { return m_width; }
93
94 void SetHeight(int h) { m_height = h; }
95 void SetWidth(int w) { m_width = w; }
96
97
98 wxGenericTreeItem *GetParent() const { return m_parent; }
99
100 // operations
101 // deletes all children notifying the treectrl about it if !NULL pointer
102 // given
103 void DeleteChildren(wxTreeCtrl *tree = NULL);
104 // FIXME don't know what is it for
105 void Reset();
106
107 // get count of all children (and grand children if 'recursively')
108 size_t GetChildrenCount(bool recursively = TRUE) const;
109
110 void Insert(wxGenericTreeItem *child, size_t index)
111 { m_children.Insert(child, index); }
112
113 void SetCross( int x, int y );
114 void GetSize( int &x, int &y, const wxTreeCtrl* );
115
116 // return the item at given position (or NULL if no item), onButton is TRUE
117 // if the point belongs to the item's button, otherwise it lies on the
118 // button's label
119 wxGenericTreeItem *HitTest( const wxPoint& point, const wxTreeCtrl *, int &flags);
120
121 void Expand() { m_isCollapsed = FALSE; }
122 void Collapse() { m_isCollapsed = TRUE; }
123
124 void SetHilight( bool set = TRUE ) { m_hasHilight = set; }
125
126 // status inquiries
127 bool HasChildren() const { return !m_children.IsEmpty(); }
128 bool HasHilight() const { return m_hasHilight; }
129 bool IsExpanded() const { return !m_isCollapsed; }
130 bool HasPlus() const { return m_hasPlus || HasChildren(); }
131 bool IsBold() const { return m_isBold; }
132
133 private:
134 wxString m_text;
135
136 int m_image,
137 m_selImage;
138
139 wxTreeItemData *m_data;
140
141 // use bitfields to save size
142 int m_isCollapsed :1;
143 int m_hasHilight :1; // same as focused
144 int m_hasPlus :1; // used for item which doesn't have
145 // children but still has a [+] button
146 int m_isBold :1; // render the label in bold font
147
148 int m_x, m_y;
149 long m_height, m_width;
150 int m_xCross, m_yCross;
151 int m_level;
152 wxArrayGenericTreeItems m_children;
153 wxGenericTreeItem *m_parent;
154 };
155
156 // =============================================================================
157 // implementation
158 // =============================================================================
159
160 #define PIXELS_PER_UNIT 10
161 // -----------------------------------------------------------------------------
162 // wxTreeEvent
163 // -----------------------------------------------------------------------------
164
165 IMPLEMENT_DYNAMIC_CLASS(wxTreeEvent, wxNotifyEvent)
166
167 wxTreeEvent::wxTreeEvent( wxEventType commandType, int id )
168 : wxNotifyEvent( commandType, id )
169 {
170 m_code = 0;
171 m_itemOld = (wxGenericTreeItem *)NULL;
172 }
173
174 // -----------------------------------------------------------------------------
175 // wxGenericTreeItem
176 // -----------------------------------------------------------------------------
177
178 wxGenericTreeItem::wxGenericTreeItem(wxGenericTreeItem *parent,
179 const wxString& text,
180 wxDC& dc,
181 int image, int selImage,
182 wxTreeItemData *data)
183 : m_text(text)
184 {
185 m_image = image;
186 m_selImage = selImage;
187 m_data = data;
188 m_x = m_y = 0;
189 m_xCross = m_yCross = 0;
190
191 m_level = 0;
192
193 m_isCollapsed = TRUE;
194 m_hasHilight = FALSE;
195 m_hasPlus = FALSE;
196 m_isBold = FALSE;
197
198 m_parent = parent;
199
200 dc.GetTextExtent( m_text, &m_width, &m_height );
201 // TODO : Add the width of the image
202 // PB : We don't know which image is shown (image, selImage)
203 // We don't even know imageList from the treectrl this item belongs to !!!
204 // At this point m_width doesn't mean much, this can be remove !
205 }
206
207 wxGenericTreeItem::~wxGenericTreeItem()
208 {
209 delete m_data;
210
211 wxASSERT_MSG( m_children.IsEmpty(),
212 _T("please call DeleteChildren() before deleting the item") );
213 }
214
215 void wxGenericTreeItem::DeleteChildren(wxTreeCtrl *tree)
216 {
217 size_t count = m_children.Count();
218 for ( size_t n = 0; n < count; n++ )
219 {
220 wxGenericTreeItem *child = m_children[n];
221 if ( tree )
222 {
223 tree->SendDeleteEvent(child);
224 }
225
226 child->DeleteChildren(tree);
227 delete child;
228 }
229
230 m_children.Empty();
231 }
232
233 void wxGenericTreeItem::SetText( const wxString &text )
234 {
235 m_text = text;
236 }
237
238 void wxGenericTreeItem::Reset()
239 {
240 m_text.Empty();
241 m_image =
242 m_selImage = -1;
243 m_data = NULL;
244 m_x = m_y =
245 m_height = m_width = 0;
246 m_xCross =
247 m_yCross = 0;
248
249 m_level = 0;
250
251 DeleteChildren();
252 m_isCollapsed = TRUE;
253
254 m_parent = (wxGenericTreeItem *)NULL;
255 }
256
257 size_t wxGenericTreeItem::GetChildrenCount(bool recursively) const
258 {
259 size_t count = m_children.Count();
260 if ( !recursively )
261 return count;
262
263 size_t total = count;
264 for ( size_t n = 0; n < count; ++n )
265 {
266 total += m_children[n]->GetChildrenCount();
267 }
268
269 return total;
270 }
271
272 void wxGenericTreeItem::SetCross( int x, int y )
273 {
274 m_xCross = x;
275 m_yCross = y;
276 }
277
278 void wxGenericTreeItem::GetSize( int &x, int &y, const wxTreeCtrl *theTree )
279 {
280 int bottomY=m_y+theTree->GetLineHeight(this);
281 if ( y < bottomY ) y = bottomY;
282 int width = m_x + m_width;
283 if ( x < width ) x = width;
284
285 if (IsExpanded())
286 {
287 size_t count = m_children.Count();
288 for ( size_t n = 0; n < count; ++n )
289 {
290 m_children[n]->GetSize( x, y, theTree );
291 }
292 }
293 }
294
295 wxGenericTreeItem *wxGenericTreeItem::HitTest( const wxPoint& point,
296 const wxTreeCtrl *theTree,
297 int &flags)
298 {
299 if ((point.y > m_y) && (point.y < m_y + theTree->GetLineHeight(this)))
300 {
301 if (point.y<m_y+theTree->GetLineHeight(this)/2) flags|=wxTREE_HITTEST_ONITEMUPPERPART;
302 else flags|=wxTREE_HITTEST_ONITEMLOWERPART;
303
304 // FIXME why +5?
305 // Because that is the size of the plus sign, RR
306 if ((point.x > m_xCross-5) && (point.x < m_xCross+5) &&
307 (point.y > m_yCross-5) && (point.y < m_yCross+5) &&
308 (IsExpanded() || HasPlus()))
309 {
310 flags|=wxTREE_HITTEST_ONITEMBUTTON;
311 return this;
312 }
313
314 if ((point.x >= m_x) && (point.x <= m_x+m_width))
315 {
316 int image_w,image_h;
317
318 // assuming every image (normal and selected ) has the same size !
319 theTree->m_imageListNormal->GetSize(m_image, image_w, image_h);
320 if (point.x<=m_x+image_w+1)
321 flags|=wxTREE_HITTEST_ONITEMICON;
322 else
323 flags|=wxTREE_HITTEST_ONITEMLABEL;
324
325 return this;
326 }
327
328 if (point.x < m_x) flags|=wxTREE_HITTEST_ONITEMIDENT;
329 if (point.x > m_x+m_width) flags|=wxTREE_HITTEST_ONITEMRIGHT;
330
331 return this;
332 }
333 else
334 {
335 if (!m_isCollapsed)
336 {
337 size_t count = m_children.Count();
338 for ( size_t n = 0; n < count; n++ )
339 {
340 wxGenericTreeItem *res = m_children[n]->HitTest( point, theTree, flags );
341 if ( res != NULL )
342 return res;
343 }
344 }
345 }
346
347 flags|=wxTREE_HITTEST_NOWHERE;
348 return NULL;
349 }
350
351 // -----------------------------------------------------------------------------
352 // wxTreeCtrl implementation
353 // -----------------------------------------------------------------------------
354
355 IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxScrolledWindow)
356
357 BEGIN_EVENT_TABLE(wxTreeCtrl,wxScrolledWindow)
358 EVT_PAINT (wxTreeCtrl::OnPaint)
359 EVT_MOUSE_EVENTS (wxTreeCtrl::OnMouse)
360 EVT_CHAR (wxTreeCtrl::OnChar)
361 EVT_SET_FOCUS (wxTreeCtrl::OnSetFocus)
362 EVT_KILL_FOCUS (wxTreeCtrl::OnKillFocus)
363 EVT_IDLE (wxTreeCtrl::OnIdle)
364 END_EVENT_TABLE()
365
366 // -----------------------------------------------------------------------------
367 // construction/destruction
368 // -----------------------------------------------------------------------------
369
370 void wxTreeCtrl::Init()
371 {
372 m_current =
373 m_key_current =
374 m_anchor = (wxGenericTreeItem *) NULL;
375 m_hasFocus = FALSE;
376 m_dirty = FALSE;
377
378 m_xScroll = 0;
379 m_yScroll = 0;
380 m_lineHeight = 10;
381 m_indent = 15;
382 m_spacing = 18;
383
384 m_hilightBrush = new wxBrush
385 (
386 wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHT),
387 wxSOLID
388 );
389
390 m_imageListNormal =
391 m_imageListState = (wxImageList *) NULL;
392
393 m_dragCount = 0;
394 }
395
396 bool wxTreeCtrl::Create(wxWindow *parent, wxWindowID id,
397 const wxPoint& pos, const wxSize& size,
398 long style,
399 const wxValidator &validator,
400 const wxString& name )
401 {
402 Init();
403
404 wxScrolledWindow::Create( parent, id, pos, size, style|wxHSCROLL|wxVSCROLL, name );
405
406 #if wxUSE_VALIDATORS
407 SetValidator( validator );
408 #endif
409
410 SetBackgroundColour( *wxWHITE );
411 m_dottedPen = wxPen( *wxBLACK, 0, 0 );
412
413 return TRUE;
414 }
415
416 wxTreeCtrl::~wxTreeCtrl()
417 {
418 wxDELETE( m_hilightBrush );
419
420 DeleteAllItems();
421 }
422
423 // -----------------------------------------------------------------------------
424 // accessors
425 // -----------------------------------------------------------------------------
426
427 size_t wxTreeCtrl::GetCount() const
428 {
429 return m_anchor == NULL ? 0u : m_anchor->GetChildrenCount();
430 }
431
432 void wxTreeCtrl::SetIndent(unsigned int indent)
433 {
434 m_indent = indent;
435 m_dirty = TRUE;
436 Refresh();
437 }
438
439 void wxTreeCtrl::SetSpacing(unsigned int spacing)
440 {
441 m_spacing = spacing;
442 m_dirty = TRUE;
443 Refresh();
444 }
445
446 size_t wxTreeCtrl::GetChildrenCount(const wxTreeItemId& item, bool recursively)
447 {
448 wxCHECK_MSG( item.IsOk(), 0u, _T("invalid tree item") );
449
450 return item.m_pItem->GetChildrenCount(recursively);
451 }
452
453 // -----------------------------------------------------------------------------
454 // functions to work with tree items
455 // -----------------------------------------------------------------------------
456
457 wxString wxTreeCtrl::GetItemText(const wxTreeItemId& item) const
458 {
459 wxCHECK_MSG( item.IsOk(), _T(""), _T("invalid tree item") );
460
461 return item.m_pItem->GetText();
462 }
463
464 int wxTreeCtrl::GetItemImage(const wxTreeItemId& item) const
465 {
466 wxCHECK_MSG( item.IsOk(), -1, _T("invalid tree item") );
467
468 return item.m_pItem->GetImage();
469 }
470
471 int wxTreeCtrl::GetItemSelectedImage(const wxTreeItemId& item) const
472 {
473 wxCHECK_MSG( item.IsOk(), -1, _T("invalid tree item") );
474
475 return item.m_pItem->GetSelectedImage();
476 }
477
478 wxTreeItemData *wxTreeCtrl::GetItemData(const wxTreeItemId& item) const
479 {
480 wxCHECK_MSG( item.IsOk(), NULL, _T("invalid tree item") );
481
482 return item.m_pItem->GetData();
483 }
484
485 void wxTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text)
486 {
487 wxCHECK_RET( item.IsOk(), _T("invalid tree item") );
488
489 wxClientDC dc(this);
490 wxGenericTreeItem *pItem = item.m_pItem;
491 pItem->SetText(text);
492 CalculateSize(pItem, dc);
493 RefreshLine(pItem);
494 }
495
496 void wxTreeCtrl::SetItemImage(const wxTreeItemId& item, int image)
497 {
498 wxCHECK_RET( item.IsOk(), _T("invalid tree item") );
499
500 wxClientDC dc(this);
501 wxGenericTreeItem *pItem = item.m_pItem;
502 pItem->SetImage(image);
503 CalculateSize(pItem, dc);
504 RefreshLine(pItem);
505 }
506
507 void wxTreeCtrl::SetItemSelectedImage(const wxTreeItemId& item, int image)
508 {
509 wxCHECK_RET( item.IsOk(), _T("invalid tree item") );
510
511 wxClientDC dc(this);
512 wxGenericTreeItem *pItem = item.m_pItem;
513 pItem->SetSelectedImage(image);
514 CalculateSize(pItem, dc);
515 RefreshLine(pItem);
516 }
517
518 void wxTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data)
519 {
520 wxCHECK_RET( item.IsOk(), _T("invalid tree item") );
521
522 item.m_pItem->SetData(data);
523 }
524
525 void wxTreeCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
526 {
527 wxCHECK_RET( item.IsOk(), _T("invalid tree item") );
528
529 wxGenericTreeItem *pItem = item.m_pItem;
530 pItem->SetHasPlus(has);
531 RefreshLine(pItem);
532 }
533
534 void wxTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
535 {
536 wxCHECK_RET( item.IsOk(), _T("invalid tree item") );
537
538 // avoid redrawing the tree if no real change
539 wxGenericTreeItem *pItem = item.m_pItem;
540 if ( pItem->IsBold() != bold )
541 {
542 pItem->SetBold(bold);
543 RefreshLine(pItem);
544 }
545 }
546
547 // -----------------------------------------------------------------------------
548 // item status inquiries
549 // -----------------------------------------------------------------------------
550
551 bool wxTreeCtrl::IsVisible(const wxTreeItemId& WXUNUSED(item)) const
552 {
553 wxFAIL_MSG(_T("not implemented"));
554
555 return TRUE;
556 }
557
558 bool wxTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const
559 {
560 wxCHECK_MSG( item.IsOk(), FALSE, _T("invalid tree item") );
561
562 return !item.m_pItem->GetChildren().IsEmpty();
563 }
564
565 bool wxTreeCtrl::IsExpanded(const wxTreeItemId& item) const
566 {
567 wxCHECK_MSG( item.IsOk(), FALSE, _T("invalid tree item") );
568
569 return item.m_pItem->IsExpanded();
570 }
571
572 bool wxTreeCtrl::IsSelected(const wxTreeItemId& item) const
573 {
574 wxCHECK_MSG( item.IsOk(), FALSE, _T("invalid tree item") );
575
576 return item.m_pItem->HasHilight();
577 }
578
579 bool wxTreeCtrl::IsBold(const wxTreeItemId& item) const
580 {
581 wxCHECK_MSG( item.IsOk(), FALSE, _T("invalid tree item") );
582
583 return item.m_pItem->IsBold();
584 }
585
586 // -----------------------------------------------------------------------------
587 // navigation
588 // -----------------------------------------------------------------------------
589
590 wxTreeItemId wxTreeCtrl::GetParent(const wxTreeItemId& item) const
591 {
592 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), _T("invalid tree item") );
593
594 return item.m_pItem->GetParent();
595 }
596
597 wxTreeItemId wxTreeCtrl::GetFirstChild(const wxTreeItemId& item, long& cookie) const
598 {
599 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), _T("invalid tree item") );
600
601 cookie = 0;
602 return GetNextChild(item, cookie);
603 }
604
605 wxTreeItemId wxTreeCtrl::GetNextChild(const wxTreeItemId& item, long& cookie) const
606 {
607 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), _T("invalid tree item") );
608
609 wxArrayGenericTreeItems& children = item.m_pItem->GetChildren();
610 if ( (size_t)cookie < children.Count() )
611 {
612 return children.Item(cookie++);
613 }
614 else
615 {
616 // there are no more of them
617 return wxTreeItemId();
618 }
619 }
620
621 wxTreeItemId wxTreeCtrl::GetLastChild(const wxTreeItemId& item) const
622 {
623 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), _T("invalid tree item") );
624
625 wxArrayGenericTreeItems& children = item.m_pItem->GetChildren();
626 return (children.IsEmpty() ? wxTreeItemId() : wxTreeItemId(children.Last()));
627 }
628
629 wxTreeItemId wxTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
630 {
631 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), _T("invalid tree item") );
632
633 wxGenericTreeItem *i = item.m_pItem;
634 wxGenericTreeItem *parent = i->GetParent();
635 if ( parent == NULL )
636 {
637 // root item doesn't have any siblings
638 return wxTreeItemId();
639 }
640
641 wxArrayGenericTreeItems& siblings = parent->GetChildren();
642 int index = siblings.Index(i);
643 wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
644
645 size_t n = (size_t)(index + 1);
646 return n == siblings.Count() ? wxTreeItemId() : wxTreeItemId(siblings[n]);
647 }
648
649 wxTreeItemId wxTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const
650 {
651 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), _T("invalid tree item") );
652
653 wxGenericTreeItem *i = item.m_pItem;
654 wxGenericTreeItem *parent = i->GetParent();
655 if ( parent == NULL )
656 {
657 // root item doesn't have any siblings
658 return wxTreeItemId();
659 }
660
661 wxArrayGenericTreeItems& siblings = parent->GetChildren();
662 int index = siblings.Index(i);
663 wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
664
665 return index == 0 ? wxTreeItemId()
666 : wxTreeItemId(siblings[(size_t)(index - 1)]);
667 }
668
669 wxTreeItemId wxTreeCtrl::GetFirstVisibleItem() const
670 {
671 wxFAIL_MSG(_T("not implemented"));
672
673 return wxTreeItemId();
674 }
675
676 wxTreeItemId wxTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
677 {
678 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), _T("invalid tree item") );
679
680 wxFAIL_MSG(_T("not implemented"));
681
682 return wxTreeItemId();
683 }
684
685 wxTreeItemId wxTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
686 {
687 wxCHECK_MSG( item.IsOk(), wxTreeItemId(), _T("invalid tree item") );
688
689 wxFAIL_MSG(_T("not implemented"));
690
691 return wxTreeItemId();
692 }
693
694 // -----------------------------------------------------------------------------
695 // operations
696 // -----------------------------------------------------------------------------
697
698 wxTreeItemId wxTreeCtrl::DoInsertItem(const wxTreeItemId& parentId,
699 size_t previous,
700 const wxString& text,
701 int image, int selImage,
702 wxTreeItemData *data)
703 {
704 wxGenericTreeItem *parent = parentId.m_pItem;
705 if ( !parent )
706 {
707 // should we give a warning here?
708 return AddRoot(text, image, selImage, data);
709 }
710
711 wxClientDC dc(this);
712 wxGenericTreeItem *item = new wxGenericTreeItem(parent,
713 text, dc,
714 image, selImage,
715 data);
716
717 if ( data != NULL )
718 {
719 data->m_pItem = item;
720 }
721
722 parent->Insert( item, previous );
723
724 m_dirty = TRUE;
725
726 return item;
727 }
728
729 wxTreeItemId wxTreeCtrl::AddRoot(const wxString& text,
730 int image, int selImage,
731 wxTreeItemData *data)
732 {
733 wxCHECK_MSG( !m_anchor, wxTreeItemId(), _T("tree can have only one root") );
734
735 wxClientDC dc(this);
736 m_anchor = new wxGenericTreeItem((wxGenericTreeItem *)NULL, text, dc,
737 image, selImage, data);
738 if ( data != NULL )
739 {
740 data->m_pItem = m_anchor;
741 }
742
743 Refresh();
744 AdjustMyScrollbars();
745
746 return m_anchor;
747 }
748
749 wxTreeItemId wxTreeCtrl::PrependItem(const wxTreeItemId& parent,
750 const wxString& text,
751 int image, int selImage,
752 wxTreeItemData *data)
753 {
754 return DoInsertItem(parent, 0u, text, image, selImage, data);
755 }
756
757 wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parentId,
758 const wxTreeItemId& idPrevious,
759 const wxString& text,
760 int image, int selImage,
761 wxTreeItemData *data)
762 {
763 wxGenericTreeItem *parent = parentId.m_pItem;
764 if ( !parent )
765 {
766 // should we give a warning here?
767 return AddRoot(text, image, selImage, data);
768 }
769
770 int index = parent->GetChildren().Index(idPrevious.m_pItem);
771 wxASSERT_MSG( index != wxNOT_FOUND,
772 _T("previous item in wxTreeCtrl::InsertItem() is not a sibling") );
773 return DoInsertItem(parentId, (size_t)++index, text, image, selImage, data);
774 }
775
776 wxTreeItemId wxTreeCtrl::AppendItem(const wxTreeItemId& parentId,
777 const wxString& text,
778 int image, int selImage,
779 wxTreeItemData *data)
780 {
781 wxGenericTreeItem *parent = parentId.m_pItem;
782 if ( !parent )
783 {
784 // should we give a warning here?
785 return AddRoot(text, image, selImage, data);
786 }
787
788 return DoInsertItem(parent, parent->GetChildren().Count(), text,
789 image, selImage, data);
790 }
791
792 void wxTreeCtrl::SendDeleteEvent(wxGenericTreeItem *item)
793 {
794 wxTreeEvent event( wxEVT_COMMAND_TREE_DELETE_ITEM, GetId() );
795 event.m_item = item;
796 event.SetEventObject( this );
797 ProcessEvent( event );
798 }
799
800 void wxTreeCtrl::DeleteChildren(const wxTreeItemId& itemId)
801 {
802 wxGenericTreeItem *item = itemId.m_pItem;
803 item->DeleteChildren(this);
804
805 m_dirty = TRUE;
806 }
807
808 void wxTreeCtrl::Delete(const wxTreeItemId& itemId)
809 {
810 wxGenericTreeItem *item = itemId.m_pItem;
811 wxGenericTreeItem *parent = item->GetParent();
812
813 if ( parent )
814 {
815 parent->GetChildren().Remove(item);
816 }
817
818 item->DeleteChildren(this);
819 SendDeleteEvent(item);
820 delete item;
821
822 m_dirty = TRUE;
823 }
824
825 void wxTreeCtrl::DeleteAllItems()
826 {
827 if ( m_anchor )
828 {
829 m_anchor->DeleteChildren(this);
830 delete m_anchor;
831
832 m_anchor = NULL;
833
834 m_dirty = TRUE;
835 }
836 }
837
838 void wxTreeCtrl::Expand(const wxTreeItemId& itemId)
839 {
840 wxGenericTreeItem *item = itemId.m_pItem;
841
842 if ( !item->HasPlus() )
843 return;
844
845 if ( item->IsExpanded() )
846 return;
847
848 wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_EXPANDING, GetId() );
849 event.m_item = item;
850 event.SetEventObject( this );
851 if ( ProcessEvent( event ) && event.m_code )
852 {
853 // cancelled by program
854 return;
855 }
856
857 item->Expand();
858 CalculatePositions();
859
860 RefreshSubtree(item);
861
862 event.SetEventType(wxEVT_COMMAND_TREE_ITEM_EXPANDED);
863 ProcessEvent( event );
864 }
865
866 void wxTreeCtrl::Collapse(const wxTreeItemId& itemId)
867 {
868 wxGenericTreeItem *item = itemId.m_pItem;
869
870 if ( !item->IsExpanded() )
871 return;
872
873 wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_COLLAPSING, GetId() );
874 event.m_item = item;
875 event.SetEventObject( this );
876 if ( ProcessEvent( event ) && event.m_code )
877 {
878 // cancelled by program
879 return;
880 }
881
882 item->Collapse();
883
884 wxArrayGenericTreeItems& children = item->GetChildren();
885 size_t count = children.Count();
886 for ( size_t n = 0; n < count; n++ )
887 {
888 Collapse(children[n]);
889 }
890
891 CalculatePositions();
892
893 RefreshSubtree(item);
894
895 event.SetEventType(wxEVT_COMMAND_TREE_ITEM_COLLAPSED);
896 ProcessEvent( event );
897 }
898
899 void wxTreeCtrl::CollapseAndReset(const wxTreeItemId& item)
900 {
901 Collapse(item);
902 DeleteChildren(item);
903 }
904
905 void wxTreeCtrl::Toggle(const wxTreeItemId& itemId)
906 {
907 wxGenericTreeItem *item = itemId.m_pItem;
908
909 if ( item->IsExpanded() )
910 Collapse(itemId);
911 else
912 Expand(itemId);
913 }
914
915 void wxTreeCtrl::Unselect()
916 {
917 if ( m_current )
918 {
919 m_current->SetHilight( FALSE );
920 RefreshLine( m_current );
921 }
922 }
923
924 void wxTreeCtrl::UnselectAllChildren(wxGenericTreeItem *item)
925 {
926 item->SetHilight(FALSE);
927 RefreshLine(item);
928
929 if (item->HasChildren())
930 {
931 wxArrayGenericTreeItems& children = item->GetChildren();
932 size_t count = children.Count();
933 for ( size_t n = 0; n < count; ++n )
934 UnselectAllChildren(children[n]);
935 }
936 }
937
938 void wxTreeCtrl::UnselectAll()
939 {
940 UnselectAllChildren(GetRootItem().m_pItem);
941 }
942
943 // Recursive function !
944 // To stop we must have crt_item<last_item
945 // Algorithm :
946 // Tag all next children, when no more children,
947 // Move to parent (not to tag)
948 // Keep going... if we found last_item, we stop.
949 bool wxTreeCtrl::TagNextChildren(wxGenericTreeItem *crt_item, wxGenericTreeItem *last_item, bool select)
950 {
951 wxGenericTreeItem *parent = crt_item->GetParent();
952
953 if ( parent == NULL ) // This is root item
954 return TagAllChildrenUntilLast(crt_item, last_item, select);
955
956 wxArrayGenericTreeItems& children = parent->GetChildren();
957 int index = children.Index(crt_item);
958 wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
959
960 size_t count = children.Count();
961 for (size_t n=(size_t)(index+1); n<count; ++n)
962 if (TagAllChildrenUntilLast(children[n], last_item, select)) return TRUE;
963
964 return TagNextChildren(parent, last_item, select);
965 }
966
967 bool wxTreeCtrl::TagAllChildrenUntilLast(wxGenericTreeItem *crt_item, wxGenericTreeItem *last_item, bool select)
968 {
969 crt_item->SetHilight(select);
970 RefreshLine(crt_item);
971
972 if (crt_item==last_item) return TRUE;
973
974 if (crt_item->HasChildren())
975 {
976 wxArrayGenericTreeItems& children = crt_item->GetChildren();
977 size_t count = children.Count();
978 for ( size_t n = 0; n < count; ++n )
979 if (TagAllChildrenUntilLast(children[n], last_item, select)) return TRUE;
980 }
981
982 return FALSE;
983 }
984
985 void wxTreeCtrl::SelectItemRange(wxGenericTreeItem *item1, wxGenericTreeItem *item2)
986 {
987 // item2 is not necessary after item1
988 wxGenericTreeItem *first=NULL, *last=NULL;
989
990 // choice first' and 'last' between item1 and item2
991 if (item1->GetY()<item2->GetY())
992 {
993 first=item1;
994 last=item2;
995 }
996 else
997 {
998 first=item2;
999 last=item1;
1000 }
1001
1002 bool select=m_current->HasHilight();
1003
1004 if (TagAllChildrenUntilLast(first,last,select)) return;
1005
1006 TagNextChildren(first,last,select);
1007 }
1008
1009 void wxTreeCtrl::SelectItem(const wxTreeItemId& itemId,
1010 bool unselect_others,
1011 bool extended_select)
1012 {
1013 bool is_single=!(GetWindowStyleFlag() & wxTR_MULTIPLE);
1014
1015 //wxCHECK_RET( ( (!unselect_others) && is_single),
1016 // _T("this is a single selection tree") );
1017
1018 // to keep going anyhow !!!
1019 if (is_single)
1020 {
1021 unselect_others=TRUE;
1022 extended_select=FALSE;
1023 }
1024
1025 wxGenericTreeItem *item = itemId.m_pItem;
1026
1027 wxTreeEvent event( wxEVT_COMMAND_TREE_SEL_CHANGING, GetId() );
1028 event.m_item = item;
1029 event.m_itemOld = m_current;
1030 event.SetEventObject( this );
1031 // TODO : Here we don't send any selection mode yet !
1032
1033 if ( GetEventHandler()->ProcessEvent( event ) && event.WasVetoed() )
1034 return;
1035
1036 // ctrl press
1037 if (unselect_others)
1038 {
1039 if (is_single) Unselect(); // to speed up thing
1040 else UnselectAll();
1041 }
1042
1043 // shift press
1044 if (extended_select)
1045 {
1046 if (m_current == NULL) m_current=m_key_current=GetRootItem().m_pItem;
1047 // don't change the mark (m_current)
1048 SelectItemRange(m_current, item);
1049 }
1050 else
1051 {
1052 bool select=TRUE; // the default
1053
1054 // Check if we need to toggle hilight (ctrl mode)
1055 if (!unselect_others)
1056 select=!item->HasHilight();
1057
1058 m_current = m_key_current = item;
1059 m_current->SetHilight(select);
1060 RefreshLine( m_current );
1061 }
1062
1063 event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
1064 GetEventHandler()->ProcessEvent( event );
1065 }
1066
1067 void wxTreeCtrl::FillArray(wxGenericTreeItem *item, wxArrayTreeItemIds &array) const
1068 {
1069 if (item->HasHilight()) array.Add(wxTreeItemId(item));
1070
1071 if (item->HasChildren())
1072 {
1073 wxArrayGenericTreeItems& children = item->GetChildren();
1074 size_t count = children.Count();
1075 for ( size_t n = 0; n < count; ++n )
1076 FillArray(children[n],array);
1077 }
1078 }
1079
1080 size_t wxTreeCtrl::GetSelections(wxArrayTreeItemIds &array) const
1081 {
1082 array.Empty();
1083 FillArray(GetRootItem().m_pItem, array);
1084
1085 return array.Count();
1086 }
1087
1088 void wxTreeCtrl::EnsureVisible(const wxTreeItemId& item)
1089 {
1090 if (!item.IsOk()) return;
1091
1092 wxGenericTreeItem *gitem = item.m_pItem;
1093
1094 // first expand all parent branches
1095 wxGenericTreeItem *parent = gitem->GetParent();
1096 while ( parent && !parent->IsExpanded() )
1097 {
1098 Expand(parent);
1099
1100 parent = parent->GetParent();
1101 }
1102
1103 if (parent) CalculatePositions();
1104
1105 ScrollTo(item);
1106 }
1107
1108 void wxTreeCtrl::ScrollTo(const wxTreeItemId &item)
1109 {
1110 if (!item.IsOk()) return;
1111
1112 wxGenericTreeItem *gitem = item.m_pItem;
1113
1114 // now scroll to the item
1115 int item_y = gitem->GetY();
1116
1117 int start_x = 0;
1118 int start_y = 0;
1119 ViewStart( &start_x, &start_y );
1120 start_y *= PIXELS_PER_UNIT;
1121
1122 int client_h = 0;
1123 int client_w = 0;
1124 GetClientSize( &client_w, &client_h );
1125
1126 if (item_y < start_y+3)
1127 {
1128 // going down
1129 int x = 0;
1130 int y = 0;
1131 m_anchor->GetSize( x, y, this );
1132 y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1133 int x_pos = GetScrollPos( wxHORIZONTAL );
1134 // Item should appear at top
1135 SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, item_y/PIXELS_PER_UNIT );
1136 }
1137 else if (item_y+GetLineHeight(gitem) > start_y+client_h)
1138 {
1139 // going up
1140 int x = 0;
1141 int y = 0;
1142 m_anchor->GetSize( x, y, this );
1143 y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1144 item_y += PIXELS_PER_UNIT+2;
1145 int x_pos = GetScrollPos( wxHORIZONTAL );
1146 // Item should appear at bottom
1147 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 );
1148 }
1149 }
1150
1151 wxTextCtrl *wxTreeCtrl::EditLabel( const wxTreeItemId& WXUNUSED(item),
1152 wxClassInfo* WXUNUSED(textCtrlClass) )
1153 {
1154 wxFAIL_MSG(_T("not implemented"));
1155
1156 return (wxTextCtrl*)NULL;
1157 }
1158
1159 wxTextCtrl *wxTreeCtrl::GetEditControl() const
1160 {
1161 wxFAIL_MSG(_T("not implemented"));
1162
1163 return (wxTextCtrl*)NULL;
1164 }
1165
1166 void wxTreeCtrl::EndEditLabel(const wxTreeItemId& WXUNUSED(item), bool WXUNUSED(discardChanges))
1167 {
1168 wxFAIL_MSG(_T("not implemented"));
1169 }
1170
1171 // FIXME: tree sorting functions are not reentrant and not MT-safe!
1172 static wxTreeCtrl *s_treeBeingSorted = NULL;
1173
1174 static int tree_ctrl_compare_func(wxGenericTreeItem **item1,
1175 wxGenericTreeItem **item2)
1176 {
1177 wxCHECK_MSG( s_treeBeingSorted, 0, _T("bug in wxTreeCtrl::SortChildren()") );
1178
1179 return s_treeBeingSorted->OnCompareItems(*item1, *item2);
1180 }
1181
1182 int wxTreeCtrl::OnCompareItems(const wxTreeItemId& item1,
1183 const wxTreeItemId& item2)
1184 {
1185 return wxStrcmp(GetItemText(item1), GetItemText(item2));
1186 }
1187
1188 void wxTreeCtrl::SortChildren(const wxTreeItemId& itemId)
1189 {
1190 wxCHECK_RET( itemId.IsOk(), _T("invalid tree item") );
1191
1192 wxGenericTreeItem *item = itemId.m_pItem;
1193
1194 wxCHECK_RET( !s_treeBeingSorted,
1195 _T("wxTreeCtrl::SortChildren is not reentrant") );
1196
1197 wxArrayGenericTreeItems& children = item->GetChildren();
1198 if ( children.Count() > 1 )
1199 {
1200 s_treeBeingSorted = this;
1201 children.Sort(tree_ctrl_compare_func);
1202 s_treeBeingSorted = NULL;
1203
1204 m_dirty = TRUE;
1205 }
1206 //else: don't make the tree dirty as nothing changed
1207 }
1208
1209 wxImageList *wxTreeCtrl::GetImageList() const
1210 {
1211 return m_imageListNormal;
1212 }
1213
1214 wxImageList *wxTreeCtrl::GetStateImageList() const
1215 {
1216 return m_imageListState;
1217 }
1218
1219 void wxTreeCtrl::SetImageList(wxImageList *imageList)
1220 {
1221 m_imageListNormal = imageList;
1222
1223 // Calculate a m_lineHeight value from the image sizes.
1224 // May be toggle off. Then wxTreeCtrl will spread when
1225 // necessary (which might look ugly).
1226 #if 1
1227 wxPaintDC dc(this);
1228 m_lineHeight = (int)(dc.GetCharHeight() + 4);
1229 int
1230 width = 0,
1231 height = 0,
1232 n = m_imageListNormal->GetImageCount();
1233 for(int i = 0; i < n ; i++)
1234 {
1235 m_imageListNormal->GetSize(i, width, height);
1236 if(height > m_lineHeight) m_lineHeight = height;
1237 }
1238
1239 if (m_lineHeight<40) m_lineHeight+=4; // at least 4 pixels (odd such that a line can be drawn in between)
1240 else m_lineHeight+=m_lineHeight/10; // otherwise 10% extra spacing
1241
1242 #endif
1243 }
1244
1245 void wxTreeCtrl::SetStateImageList(wxImageList *imageList)
1246 {
1247 m_imageListState = imageList;
1248 }
1249
1250 // -----------------------------------------------------------------------------
1251 // helpers
1252 // -----------------------------------------------------------------------------
1253
1254 void wxTreeCtrl::AdjustMyScrollbars()
1255 {
1256 if (m_anchor)
1257 {
1258 int x = 0;
1259 int y = 0;
1260 m_anchor->GetSize( x, y, this );
1261 //y += GetLineHeight(m_anchor);
1262 y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1263 int x_pos = GetScrollPos( wxHORIZONTAL );
1264 int y_pos = GetScrollPos( wxVERTICAL );
1265 SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, y_pos );
1266 }
1267 else
1268 {
1269 SetScrollbars( 0, 0, 0, 0 );
1270 }
1271 }
1272
1273 int wxTreeCtrl::GetLineHeight(wxGenericTreeItem *item) const
1274 {
1275 if (GetWindowStyleFlag() & wxTR_HAS_VARIABLE_ROW_HIGHT)
1276 return item->GetHeight();
1277 else
1278 return m_lineHeight;
1279 }
1280
1281 void wxTreeCtrl::PaintItem(wxGenericTreeItem *item, wxDC& dc)
1282 {
1283 // render bold items in bold
1284 wxFont fontOld;
1285 wxFont fontNew;
1286
1287 if (item->IsBold())
1288 {
1289 fontOld = dc.GetFont();
1290 if (fontOld.Ok())
1291 {
1292 // VZ: is there any better way to make a bold variant of old font?
1293 fontNew = wxFont( fontOld.GetPointSize(),
1294 fontOld.GetFamily(),
1295 fontOld.GetStyle(),
1296 wxBOLD,
1297 fontOld.GetUnderlined());
1298 dc.SetFont(fontNew);
1299 }
1300 else
1301 {
1302 wxFAIL_MSG(_T("wxDC::GetFont() failed!"));
1303 }
1304 }
1305
1306 long text_w = 0;
1307 long text_h = 0;
1308 dc.GetTextExtent( item->GetText(), &text_w, &text_h );
1309
1310 int image_h = 0;
1311 int image_w = 0;
1312 if ((item->IsExpanded()) && (item->GetSelectedImage() != -1))
1313 {
1314 m_imageListNormal->GetSize( item->GetSelectedImage(), image_w, image_h );
1315 image_w += 4;
1316 }
1317 else if (item->GetImage() != -1)
1318 {
1319 m_imageListNormal->GetSize( item->GetImage(), image_w, image_h );
1320 image_w += 4;
1321 }
1322
1323 int total_h = GetLineHeight(item);
1324
1325 dc.DrawRectangle( item->GetX()-2, item->GetY(), item->GetWidth()+2, total_h );
1326
1327 if ((item->IsExpanded()) && (item->GetSelectedImage() != -1))
1328 {
1329 dc.SetClippingRegion( item->GetX(), item->GetY(), image_w-2, total_h );
1330 m_imageListNormal->Draw( item->GetSelectedImage(), dc,
1331 item->GetX(),
1332 item->GetY() +((total_h > image_h)?((total_h-image_h)/2):0),
1333 wxIMAGELIST_DRAW_TRANSPARENT );
1334 dc.DestroyClippingRegion();
1335 }
1336 else if (item->GetImage() != -1)
1337 {
1338 dc.SetClippingRegion( item->GetX(), item->GetY(), image_w-2, total_h );
1339 m_imageListNormal->Draw( item->GetImage(), dc,
1340 item->GetX(),
1341 item->GetY() +((total_h > image_h)?((total_h-image_h)/2):0),
1342 wxIMAGELIST_DRAW_TRANSPARENT );
1343 dc.DestroyClippingRegion();
1344 }
1345
1346 dc.SetBackgroundMode(wxTRANSPARENT);
1347 dc.DrawText( item->GetText(), image_w + item->GetX(), item->GetY()
1348 + ((total_h > text_h) ? (total_h - text_h)/2 : 0));
1349
1350 // restore normal font for bold items
1351 if (fontOld.Ok())
1352 {
1353 dc.SetFont( fontOld);
1354 }
1355 }
1356
1357 // Now y stands for the top of the item, whereas it used to stand for middle !
1358 void wxTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y )
1359 {
1360 int horizX = level*m_indent;
1361
1362 item->SetX( horizX+m_indent+m_spacing );
1363 item->SetY( y );
1364
1365 int oldY = y;
1366 y+=GetLineHeight(item)/2;
1367
1368 item->SetCross( horizX+m_indent, y );
1369
1370 int exposed_x = dc.LogicalToDeviceX( 0 );
1371 int exposed_y = dc.LogicalToDeviceY( item->GetY()-2 );
1372
1373 if (IsExposed( exposed_x, exposed_y, 10000, GetLineHeight(item)+4 )) // 10000 = very much
1374 {
1375 int startX = horizX;
1376 int endX = horizX + (m_indent-5);
1377
1378 // if (!item->HasChildren()) endX += (m_indent+5);
1379 if (!item->HasChildren()) endX += 20;
1380
1381 dc.DrawLine( startX, y, endX, y );
1382
1383 if (item->HasPlus())
1384 {
1385 dc.DrawLine( horizX+(m_indent+5), y, horizX+(m_indent+15), y );
1386 dc.SetPen( *wxGREY_PEN );
1387 dc.SetBrush( *wxWHITE_BRUSH );
1388 dc.DrawRectangle( horizX+(m_indent-5), y-4, 11, 9 );
1389 dc.SetPen( *wxBLACK_PEN );
1390 dc.DrawLine( horizX+(m_indent-2), y, horizX+(m_indent+3), y );
1391
1392 if (!item->IsExpanded())
1393 {
1394 dc.DrawLine( horizX+m_indent, y-2, horizX+m_indent, y+3 );
1395 }
1396 }
1397
1398 if (item->HasHilight())
1399 {
1400 dc.SetTextForeground( wxSystemSettings::GetSystemColour( wxSYS_COLOUR_HIGHLIGHTTEXT ) );
1401
1402 dc.SetBrush( *m_hilightBrush );
1403
1404 if (m_hasFocus)
1405 dc.SetPen( *wxBLACK_PEN );
1406 else
1407 dc.SetPen( *wxTRANSPARENT_PEN );
1408
1409 PaintItem(item, dc);
1410
1411 dc.SetPen( *wxBLACK_PEN );
1412 dc.SetTextForeground( *wxBLACK );
1413 dc.SetBrush( *wxWHITE_BRUSH );
1414 }
1415 else
1416 {
1417 dc.SetBrush( *wxWHITE_BRUSH );
1418 dc.SetPen( *wxTRANSPARENT_PEN );
1419
1420 PaintItem(item, dc);
1421
1422 dc.SetPen( *wxBLACK_PEN );
1423 }
1424 }
1425
1426 y = oldY+GetLineHeight(item);
1427
1428 if (item->IsExpanded())
1429 {
1430 oldY+=GetLineHeight(item)/2;
1431 int semiOldY=y; // (=y) for stupid compilator
1432
1433 wxArrayGenericTreeItems& children = item->GetChildren();
1434 size_t n, count = children.Count();
1435 for ( n = 0; n < count; ++n )
1436 {
1437 semiOldY=y;
1438 PaintLevel( children[n], dc, level+1, y );
1439 }
1440
1441 // it may happen that the item is expanded but has no items (when you
1442 // delete all its children for example) - don't draw the vertical line
1443 // in this case
1444 if (count > 0)
1445 {
1446 semiOldY+=GetLineHeight(children[--n])/2;
1447 dc.DrawLine( horizX+m_indent, oldY+5, horizX+m_indent, semiOldY );
1448 }
1449 }
1450 }
1451
1452 void wxTreeCtrl::DrawBorder(wxTreeItemId &item)
1453 {
1454 if (!item) return;
1455
1456 wxGenericTreeItem *i=item.m_pItem;
1457
1458 wxPaintDC dc(this);
1459 PrepareDC( dc );
1460 dc.SetLogicalFunction(wxINVERT);
1461
1462 int w,h,x;
1463 ViewStart(&x,&h); // we only need x
1464 GetClientSize(&w,&h); // we only need w
1465
1466 h=GetLineHeight(i)+1;
1467 // 2 white column at border
1468 dc.DrawRectangle( PIXELS_PER_UNIT*x+2, i->GetY()-1, w-6, h);
1469 }
1470
1471 void wxTreeCtrl::DrawLine(wxTreeItemId &item, bool below)
1472 {
1473 if (!item) return;
1474
1475 wxGenericTreeItem *i=item.m_pItem;
1476
1477 wxPaintDC dc(this);
1478 PrepareDC( dc );
1479 dc.SetLogicalFunction(wxINVERT);
1480
1481 int w,h,y;
1482 GetSize(&w,&h);
1483
1484 if (below) y=i->GetY()+GetLineHeight(i)-1;
1485 else y=i->GetY();
1486
1487 dc.DrawLine( 0, y, w, y);
1488 }
1489
1490 // -----------------------------------------------------------------------------
1491 // wxWindows callbacks
1492 // -----------------------------------------------------------------------------
1493
1494 void wxTreeCtrl::OnPaint( wxPaintEvent &WXUNUSED(event) )
1495 {
1496 if ( !m_anchor)
1497 return;
1498
1499 wxPaintDC dc(this);
1500 PrepareDC( dc );
1501
1502 dc.SetFont( wxSystemSettings::GetSystemFont( wxSYS_DEFAULT_GUI_FONT ) );
1503
1504 dc.SetPen( m_dottedPen );
1505 //if(GetImageList() == NULL)
1506 // m_lineHeight = (int)(dc.GetCharHeight() + 4);
1507
1508 int y = 2;
1509 PaintLevel( m_anchor, dc, 0, y );
1510 }
1511
1512 void wxTreeCtrl::OnSetFocus( wxFocusEvent &WXUNUSED(event) )
1513 {
1514 m_hasFocus = TRUE;
1515
1516 if (m_current) RefreshLine( m_current );
1517 }
1518
1519 void wxTreeCtrl::OnKillFocus( wxFocusEvent &WXUNUSED(event) )
1520 {
1521 m_hasFocus = FALSE;
1522
1523 if (m_current) RefreshLine( m_current );
1524 }
1525
1526 void wxTreeCtrl::OnChar( wxKeyEvent &event )
1527 {
1528 wxTreeEvent te( wxEVT_COMMAND_TREE_KEY_DOWN, GetId() );
1529 te.m_code = event.KeyCode();
1530 te.SetEventObject( this );
1531 GetEventHandler()->ProcessEvent( te );
1532
1533 if ( (m_current == 0) || (m_key_current == 0) )
1534 {
1535 event.Skip();
1536 return;
1537 }
1538
1539 bool is_multiple=(GetWindowStyleFlag() & wxTR_MULTIPLE);
1540 bool extended_select=(event.ShiftDown() && is_multiple);
1541 bool unselect_others=!(extended_select || (event.ControlDown() && is_multiple));
1542
1543 switch (event.KeyCode())
1544 {
1545 case '+':
1546 case WXK_ADD:
1547 if (m_current->HasPlus() && !IsExpanded(m_current))
1548 {
1549 Expand(m_current);
1550 }
1551 break;
1552
1553 case '-':
1554 case WXK_SUBTRACT:
1555 if (IsExpanded(m_current))
1556 {
1557 Collapse(m_current);
1558 }
1559 break;
1560
1561 case '*':
1562 case WXK_MULTIPLY:
1563 Toggle(m_current);
1564 break;
1565
1566 case ' ':
1567 case WXK_RETURN:
1568 {
1569 wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
1570 event.m_item = m_current;
1571 event.m_code = 0;
1572 event.SetEventObject( this );
1573 GetEventHandler()->ProcessEvent( event );
1574 }
1575 break;
1576
1577 // up goes to the previous sibling or to the last of its children if
1578 // it's expanded
1579 case WXK_UP:
1580 {
1581 wxTreeItemId prev = GetPrevSibling( m_key_current );
1582 if (!prev)
1583 {
1584 prev = GetParent( m_key_current );
1585 if (prev)
1586 {
1587 long cockie = 0;
1588 wxTreeItemId current = m_key_current;
1589 if (current == GetFirstChild( prev, cockie ))
1590 {
1591 // otherwise we return to where we came from
1592 SelectItem( prev, unselect_others, extended_select );
1593 m_key_current=prev.m_pItem;
1594 EnsureVisible( prev );
1595 break;
1596 }
1597 }
1598 }
1599 if (prev)
1600 {
1601 while ( IsExpanded(prev) && HasChildren(prev) )
1602 {
1603 wxTreeItemId child = GetLastChild(prev);
1604 if ( child )
1605 {
1606 prev = child;
1607 }
1608 }
1609
1610 SelectItem( prev, unselect_others, extended_select );
1611 m_key_current=prev.m_pItem;
1612 EnsureVisible( prev );
1613 }
1614 }
1615 break;
1616
1617 // left arrow goes to the parent
1618 case WXK_LEFT:
1619 {
1620 wxTreeItemId prev = GetParent( m_current );
1621 if (prev)
1622 {
1623 EnsureVisible( prev );
1624 SelectItem( prev, unselect_others, extended_select );
1625 }
1626 }
1627 break;
1628
1629 case WXK_RIGHT:
1630 // this works the same as the down arrow except that we also expand the
1631 // item if it wasn't expanded yet
1632 Expand(m_current);
1633 // fall through
1634
1635 case WXK_DOWN:
1636 {
1637 if (IsExpanded(m_key_current) && HasChildren(m_key_current))
1638 {
1639 long cookie = 0;
1640 wxTreeItemId child = GetFirstChild( m_key_current, cookie );
1641 SelectItem( child, unselect_others, extended_select );
1642 m_key_current=child.m_pItem;
1643 EnsureVisible( child );
1644 }
1645 else
1646 {
1647 wxTreeItemId next = GetNextSibling( m_key_current );
1648 if (next == 0)
1649 {
1650 wxTreeItemId current = m_key_current;
1651 while (current && !next)
1652 {
1653 current = GetParent( current );
1654 if (current) next = GetNextSibling( current );
1655 }
1656 }
1657 if (next != 0)
1658 {
1659 SelectItem( next, unselect_others, extended_select );
1660 m_key_current=next.m_pItem;
1661 EnsureVisible( next );
1662 }
1663 }
1664 }
1665 break;
1666
1667 // <End> selects the last visible tree item
1668 case WXK_END:
1669 {
1670 wxTreeItemId last = GetRootItem();
1671
1672 while ( last.IsOk() && IsExpanded(last) )
1673 {
1674 wxTreeItemId lastChild = GetLastChild(last);
1675
1676 // it may happen if the item was expanded but then all of
1677 // its children have been deleted - so IsExpanded() returned
1678 // TRUE, but GetLastChild() returned invalid item
1679 if ( !lastChild )
1680 break;
1681
1682 last = lastChild;
1683 }
1684
1685 if ( last.IsOk() )
1686 {
1687 EnsureVisible( last );
1688 SelectItem( last, unselect_others, extended_select );
1689 }
1690 }
1691 break;
1692
1693 // <Home> selects the root item
1694 case WXK_HOME:
1695 {
1696 wxTreeItemId prev = GetRootItem();
1697 if (prev)
1698 {
1699 EnsureVisible( prev );
1700 SelectItem( prev, unselect_others, extended_select );
1701 }
1702 }
1703 break;
1704
1705 default:
1706 event.Skip();
1707 }
1708 }
1709
1710 wxTreeItemId wxTreeCtrl::HitTest(const wxPoint& point, int& flags)
1711 {
1712 wxClientDC dc(this);
1713 PrepareDC(dc);
1714 long x = dc.DeviceToLogicalX( (long)point.x );
1715 long y = dc.DeviceToLogicalY( (long)point.y );
1716 int w, h;
1717 GetSize(&w, &h);
1718
1719 flags=0;
1720 if (point.x<0) flags|=wxTREE_HITTEST_TOLEFT;
1721 if (point.x>w) flags|=wxTREE_HITTEST_TORIGHT;
1722 if (point.y<0) flags|=wxTREE_HITTEST_ABOVE;
1723 if (point.y>h) flags|=wxTREE_HITTEST_BELOW;
1724
1725 return m_anchor->HitTest( wxPoint(x, y), this, flags);
1726 }
1727
1728 void wxTreeCtrl::OnMouse( wxMouseEvent &event )
1729 {
1730 if (!event.LeftIsDown()) m_dragCount = 0;
1731
1732 if ( !(event.LeftUp() || event.LeftDClick() || event.Dragging()) ) return;
1733
1734 if ( !m_anchor ) return;
1735
1736 wxClientDC dc(this);
1737 PrepareDC(dc);
1738 long x = dc.DeviceToLogicalX( (long)event.GetX() );
1739 long y = dc.DeviceToLogicalY( (long)event.GetY() );
1740
1741 int flags=0;
1742 wxGenericTreeItem *item = m_anchor->HitTest( wxPoint(x,y), this, flags);
1743 bool onButton = flags & wxTREE_HITTEST_ONITEMBUTTON;
1744
1745 if (item == NULL) return; /* we hit the blank area */
1746
1747 if (event.Dragging())
1748 {
1749 if (m_dragCount == 2) /* small drag latency (3?) */
1750 {
1751 m_dragCount = 0;
1752
1753 wxTreeEvent nevent(wxEVT_COMMAND_TREE_BEGIN_DRAG, GetId());
1754 nevent.m_item = m_current;
1755 nevent.SetEventObject(this);
1756 GetEventHandler()->ProcessEvent(nevent);
1757 }
1758 else
1759 {
1760 m_dragCount++;
1761 }
1762 return;
1763 }
1764
1765 bool is_multiple=(GetWindowStyleFlag() & wxTR_MULTIPLE);
1766 bool extended_select=(event.ShiftDown() && is_multiple);
1767 bool unselect_others=!(extended_select || (event.ControlDown() && is_multiple));
1768
1769 if (onButton)
1770 {
1771 Toggle( item );
1772 if (is_multiple) return;
1773 }
1774
1775 SelectItem(item, unselect_others, extended_select);
1776
1777 if (event.LeftDClick())
1778 {
1779 wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
1780 event.m_item = item;
1781 event.m_code = 0;
1782 event.SetEventObject( this );
1783 GetEventHandler()->ProcessEvent( event );
1784 }
1785 }
1786
1787 void wxTreeCtrl::OnIdle( wxIdleEvent &WXUNUSED(event) )
1788 {
1789 /* after all changes have been done to the tree control,
1790 * we actually redraw the tree when everything is over */
1791
1792 if (!m_dirty)
1793 return;
1794
1795 m_dirty = FALSE;
1796
1797 CalculatePositions();
1798 Refresh();
1799 AdjustMyScrollbars();
1800 }
1801
1802 void wxTreeCtrl::CalculateSize( wxGenericTreeItem *item, wxDC &dc )
1803 {
1804 long text_w = 0;
1805 long text_h = 0;
1806 // TODO : check for boldness. Here with suppose that font normal and bold
1807 // have the same height !
1808 // TODO : bug here, text_w is sometime not the correct answer !!!
1809 dc.GetTextExtent( item->GetText(), &text_w, &text_h );
1810 text_h+=4;
1811
1812 int image_h = 0;
1813 int image_w = 0;
1814 if ((item->IsExpanded()) && (item->GetSelectedImage() != -1))
1815 {
1816 m_imageListNormal->GetSize( item->GetSelectedImage(), image_w, image_h );
1817 image_w += 4;
1818 }
1819 else if (item->GetImage() != -1)
1820 {
1821 m_imageListNormal->GetSize( item->GetImage(), image_w, image_h );
1822 image_w += 4;
1823 }
1824
1825 int total_h = (image_h > text_h) ? image_h : text_h;
1826
1827 if (total_h<40) total_h+=4; // at least 4 pixels
1828 else total_h+=total_h/10; // otherwise 10% extra spacing
1829
1830 item->SetHeight(total_h);
1831 if (total_h>m_lineHeight) m_lineHeight=total_h;
1832
1833 item->SetWidth(image_w+text_w+2);
1834 }
1835
1836 // -----------------------------------------------------------------------------
1837 // for developper : y is now the top of the level
1838 // not the middle of it !
1839 void wxTreeCtrl::CalculateLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y )
1840 {
1841 int horizX = level*m_indent;
1842
1843 CalculateSize( item, dc );
1844
1845 // set its position
1846 item->SetX( horizX+m_indent+m_spacing );
1847 item->SetY( y );
1848 y+=GetLineHeight(item);
1849
1850 if ( !item->IsExpanded() )
1851 {
1852 // we dont need to calculate collapsed branches
1853 return;
1854 }
1855
1856 wxArrayGenericTreeItems& children = item->GetChildren();
1857 size_t n, count = children.Count();
1858 for (n = 0; n < count; ++n )
1859 CalculateLevel( children[n], dc, level+1, y ); // recurse
1860 }
1861
1862 void wxTreeCtrl::CalculatePositions()
1863 {
1864 if ( !m_anchor ) return;
1865
1866 wxClientDC dc(this);
1867 PrepareDC( dc );
1868
1869 dc.SetFont( wxSystemSettings::GetSystemFont( wxSYS_DEFAULT_GUI_FONT ) );
1870
1871 dc.SetPen( m_dottedPen );
1872 //if(GetImageList() == NULL)
1873 // m_lineHeight = (int)(dc.GetCharHeight() + 4);
1874
1875 int y = 2; //GetLineHeight(m_anchor) / 2 + 2;
1876 CalculateLevel( m_anchor, dc, 0, y ); // start recursion
1877 }
1878
1879 void wxTreeCtrl::RefreshSubtree(wxGenericTreeItem *item)
1880 {
1881 wxClientDC dc(this);
1882 PrepareDC(dc);
1883
1884 int cw = 0;
1885 int ch = 0;
1886 GetClientSize( &cw, &ch );
1887
1888 wxRect rect;
1889 rect.x = dc.LogicalToDeviceX( 0 );
1890 rect.width = cw;
1891 rect.y = dc.LogicalToDeviceY( item->GetY() );
1892 rect.height = ch;
1893
1894 Refresh( TRUE, &rect );
1895
1896 AdjustMyScrollbars();
1897 }
1898
1899 void wxTreeCtrl::RefreshLine( wxGenericTreeItem *item )
1900 {
1901 wxClientDC dc(this);
1902 PrepareDC( dc );
1903
1904 wxRect rect;
1905 rect.x = dc.LogicalToDeviceX( item->GetX() - 2 );
1906 rect.y = dc.LogicalToDeviceY( item->GetY());
1907 rect.width = 1000;
1908 rect.height = GetLineHeight(item); //dc.GetCharHeight() + 6;
1909
1910 Refresh( TRUE, &rect );
1911 }
1912
wxWidgets (Impactor)