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