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