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