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