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