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