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