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