src/generic/treectlg.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        treectlg.cpp
   3 // Purpose:     generic tree control implementation
   4 // Author:      Robert Roebling
   5 // Created:     01/02/97
   6 // Modified:    22/10/98 - almost total rewrite, simpler interface (VZ)
   7 // Id:          $Id$
   8 // Copyright:   (c) 1998 Robert Roebling and Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // =============================================================================
  13 // declarations
  14 // =============================================================================
  15
  16 // -----------------------------------------------------------------------------
  17 // headers
  18 // -----------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #if wxUSE_TREECTRL
  28
  29 #include "wx/treebase.h"
  30 #include "wx/treectrl.h"
  31 #include "wx/generic/treectlg.h"
  32 #include "wx/timer.h"
  33 #include "wx/textctrl.h"
  34 #include "wx/imaglist.h"
  35 #include "wx/settings.h"
  36 #include "wx/dcclient.h"
  37
  38 #include "wx/renderer.h"
  39
  40 #ifdef __WXMAC__
  41     #include "wx/mac/private.h"
  42 #endif
  43
  44 // -----------------------------------------------------------------------------
  45 // array types
  46 // -----------------------------------------------------------------------------
  47
  48 class WXDLLEXPORT wxGenericTreeItem;
  49
  50 WX_DEFINE_EXPORTED_ARRAY_PTR(wxGenericTreeItem *, wxArrayGenericTreeItems);
  51
  52 // ----------------------------------------------------------------------------
  53 // constants
  54 // ----------------------------------------------------------------------------
  55
  56 static const int NO_IMAGE = -1;
  57
  58 static const int PIXELS_PER_UNIT = 10;
  59
  60 // the margin between the item image and the item text
  61 static const int MARGIN_BETWEEN_IMAGE_AND_TEXT = 4;
  62
  63 // -----------------------------------------------------------------------------
  64 // private classes
  65 // -----------------------------------------------------------------------------
  66
  67 // timer used for enabling in-place edit
  68 class WXDLLEXPORT wxTreeRenameTimer: public wxTimer
  69 {
  70 public:
  71     // start editing the current item after half a second (if the mouse hasn't
  72     // been clicked/moved)
  73     enum { DELAY = 500 };
  74
  75     wxTreeRenameTimer( wxGenericTreeCtrl *owner );
  76
  77     virtual void Notify();
  78
  79 private:
  80     wxGenericTreeCtrl *m_owner;
  81
  82     DECLARE_NO_COPY_CLASS(wxTreeRenameTimer)
  83 };
  84
  85 // control used for in-place edit
  86 class WXDLLEXPORT wxTreeTextCtrl: public wxTextCtrl
  87 {
  88 public:
  89     wxTreeTextCtrl(wxGenericTreeCtrl *owner, wxGenericTreeItem *item);
  90
  91     void EndEdit(bool discardChanges = false)
  92     {
  93         if ( discardChanges )
  94         {
  95             StopEditing();
  96         }
  97         else
  98         {
  99             m_aboutToFinish = true;
 100
 101             // Notify the owner about the changes
 102             AcceptChanges();
 103
 104             // Even if vetoed, close the control (consistent with MSW)
 105             Finish();
 106         }
 107     }
 108
 109     void StopEditing()
 110     {
 111         Finish();
 112         m_owner->OnRenameCancelled(m_itemEdited);
 113     }
 114     const wxGenericTreeItem* item() const { return m_itemEdited; }
 115
 116 protected:
 117     void OnChar( wxKeyEvent &event );
 118     void OnKeyUp( wxKeyEvent &event );
 119     void OnKillFocus( wxFocusEvent &event );
 120
 121     bool AcceptChanges();
 122     void Finish();
 123
 124 private:
 125     wxGenericTreeCtrl  *m_owner;
 126     wxGenericTreeItem  *m_itemEdited;
 127     wxString            m_startValue;
 128     bool                m_finished;
 129     bool                m_aboutToFinish;
 130
 131     DECLARE_EVENT_TABLE()
 132     DECLARE_NO_COPY_CLASS(wxTreeTextCtrl)
 133 };
 134
 135 // timer used to clear wxGenericTreeCtrl::m_findPrefix if no key was pressed
 136 // for a sufficiently long time
 137 class WXDLLEXPORT wxTreeFindTimer : public wxTimer
 138 {
 139 public:
 140     // reset the current prefix after half a second of inactivity
 141     enum { DELAY = 500 };
 142
 143     wxTreeFindTimer( wxGenericTreeCtrl *owner ) { m_owner = owner; }
 144
 145     virtual void Notify() { m_owner->m_findPrefix.clear(); }
 146
 147 private:
 148     wxGenericTreeCtrl *m_owner;
 149
 150     DECLARE_NO_COPY_CLASS(wxTreeFindTimer)
 151 };
 152
 153 // a tree item
 154 class WXDLLEXPORT wxGenericTreeItem
 155 {
 156 public:
 157     // ctors & dtor
 158     wxGenericTreeItem() { m_data = NULL; }
 159     wxGenericTreeItem( wxGenericTreeItem *parent,
 160                        const wxString& text,
 161                        int image,
 162                        int selImage,
 163                        wxTreeItemData *data );
 164
 165     ~wxGenericTreeItem();
 166
 167     // trivial accessors
 168     wxArrayGenericTreeItems& GetChildren() { return m_children; }
 169
 170     const wxString& GetText() const { return m_text; }
 171     int GetImage(wxTreeItemIcon which = wxTreeItemIcon_Normal) const
 172         { return m_images[which]; }
 173     wxTreeItemData *GetData() const { return m_data; }
 174
 175     // returns the current image for the item (depending on its
 176     // selected/expanded/whatever state)
 177     int GetCurrentImage() const;
 178
 179     void SetText( const wxString &text );
 180     void SetImage(int image, wxTreeItemIcon which) { m_images[which] = image; }
 181     void SetData(wxTreeItemData *data) { m_data = data; }
 182
 183     void SetHasPlus(bool has = true) { m_hasPlus = has; }
 184
 185     void SetBold(bool bold) { m_isBold = bold; }
 186
 187     int GetX() const { return m_x; }
 188     int GetY() const { return m_y; }
 189
 190     void SetX(int x) { m_x = x; }
 191     void SetY(int y) { m_y = y; }
 192
 193     int  GetHeight() const { return m_height; }
 194     int  GetWidth()  const { return m_width; }
 195
 196     void SetHeight(int h) { m_height = h; }
 197     void SetWidth(int w) { m_width = w; }
 198
 199     wxGenericTreeItem *GetParent() const { return m_parent; }
 200
 201     // operations
 202         // deletes all children notifying the treectrl about it if !NULL
 203         // pointer given
 204     void DeleteChildren(wxGenericTreeCtrl *tree = NULL);
 205
 206     // get count of all children (and grand children if 'recursively')
 207     size_t GetChildrenCount(bool recursively = true) const;
 208
 209     void Insert(wxGenericTreeItem *child, size_t index)
 210     { m_children.Insert(child, index); }
 211
 212     void GetSize( int &x, int &y, const wxGenericTreeCtrl* );
 213
 214         // return the item at given position (or NULL if no item), onButton is
 215         // true if the point belongs to the item's button, otherwise it lies
 216         // on the item's label
 217     wxGenericTreeItem *HitTest( const wxPoint& point,
 218                                 const wxGenericTreeCtrl *,
 219                                 int &flags,
 220                                 int level );
 221
 222     void Expand() { m_isCollapsed = false; }
 223     void Collapse() { m_isCollapsed = true; }
 224
 225     void SetHilight( bool set = true ) { m_hasHilight = set; }
 226
 227     // status inquiries
 228     bool HasChildren() const { return !m_children.IsEmpty(); }
 229     bool IsSelected()  const { return m_hasHilight != 0; }
 230     bool IsExpanded()  const { return !m_isCollapsed; }
 231     bool HasPlus()     const { return m_hasPlus || HasChildren(); }
 232     bool IsBold()      const { return m_isBold != 0; }
 233
 234     // attributes
 235         // get them - may be NULL
 236     wxTreeItemAttr *GetAttributes() const { return m_attr; }
 237         // get them ensuring that the pointer is not NULL
 238     wxTreeItemAttr& Attr()
 239     {
 240         if ( !m_attr )
 241         {
 242             m_attr = new wxTreeItemAttr;
 243             m_ownsAttr = true;
 244         }
 245         return *m_attr;
 246     }
 247         // set them
 248     void SetAttributes(wxTreeItemAttr *attr)
 249     {
 250         if ( m_ownsAttr ) delete m_attr;
 251         m_attr = attr;
 252         m_ownsAttr = false;
 253     }
 254         // set them and delete when done
 255     void AssignAttributes(wxTreeItemAttr *attr)
 256     {
 257         SetAttributes(attr);
 258         m_ownsAttr = true;
 259     }
 260
 261 private:
 262     // since there can be very many of these, we save size by chosing
 263     // the smallest representation for the elements and by ordering
 264     // the members to avoid padding.
 265     wxString            m_text;         // label to be rendered for item
 266
 267     wxTreeItemData     *m_data;         // user-provided data
 268
 269     wxArrayGenericTreeItems m_children; // list of children
 270     wxGenericTreeItem  *m_parent;       // parent of this item
 271
 272     wxTreeItemAttr     *m_attr;         // attributes???
 273
 274     // tree ctrl images for the normal, selected, expanded and
 275     // expanded+selected states
 276     int                 m_images[wxTreeItemIcon_Max];
 277
 278     wxCoord             m_x;            // (virtual) offset from top
 279     wxCoord             m_y;            // (virtual) offset from left
 280     int                 m_width;        // width of this item
 281     int                 m_height;       // height of this item
 282
 283     // use bitfields to save size
 284     unsigned int        m_isCollapsed :1;
 285     unsigned int        m_hasHilight  :1; // same as focused
 286     unsigned int        m_hasPlus     :1; // used for item which doesn't have
 287                                           // children but has a [+] button
 288     unsigned int        m_isBold      :1; // render the label in bold font
 289     unsigned int        m_ownsAttr    :1; // delete attribute when done
 290
 291     DECLARE_NO_COPY_CLASS(wxGenericTreeItem)
 292 };
 293
 294 // =============================================================================
 295 // implementation
 296 // =============================================================================
 297
 298 // ----------------------------------------------------------------------------
 299 // private functions
 300 // ----------------------------------------------------------------------------
 301
 302 // translate the key or mouse event flags to the type of selection we're
 303 // dealing with
 304 static void EventFlagsToSelType(long style,
 305                                 bool shiftDown,
 306                                 bool ctrlDown,
 307                                 bool &is_multiple,
 308                                 bool &extended_select,
 309                                 bool &unselect_others)
 310 {
 311     is_multiple = (style & wxTR_MULTIPLE) != 0;
 312     extended_select = shiftDown && is_multiple;
 313     unselect_others = !(extended_select || (ctrlDown && is_multiple));
 314 }
 315
 316 // check if the given item is under another one
 317 static bool IsDescendantOf(const wxGenericTreeItem *parent, const wxGenericTreeItem *item)
 318 {
 319     while ( item )
 320     {
 321         if ( item == parent )
 322         {
 323             // item is a descendant of parent
 324             return true;
 325         }
 326
 327         item = item->GetParent();
 328     }
 329
 330     return false;
 331 }
 332
 333 // -----------------------------------------------------------------------------
 334 // wxTreeRenameTimer (internal)
 335 // -----------------------------------------------------------------------------
 336
 337 wxTreeRenameTimer::wxTreeRenameTimer( wxGenericTreeCtrl *owner )
 338 {
 339     m_owner = owner;
 340 }
 341
 342 void wxTreeRenameTimer::Notify()
 343 {
 344     m_owner->OnRenameTimer();
 345 }
 346
 347 //-----------------------------------------------------------------------------
 348 // wxTreeTextCtrl (internal)
 349 //-----------------------------------------------------------------------------
 350
 351 BEGIN_EVENT_TABLE(wxTreeTextCtrl,wxTextCtrl)
 352     EVT_CHAR           (wxTreeTextCtrl::OnChar)
 353     EVT_KEY_UP         (wxTreeTextCtrl::OnKeyUp)
 354     EVT_KILL_FOCUS     (wxTreeTextCtrl::OnKillFocus)
 355 END_EVENT_TABLE()
 356
 357 wxTreeTextCtrl::wxTreeTextCtrl(wxGenericTreeCtrl *owner,
 358                                wxGenericTreeItem *item)
 359               : m_itemEdited(item), m_startValue(item->GetText())
 360 {
 361     m_owner = owner;
 362     m_finished = false;
 363     m_aboutToFinish = false;
 364
 365     int w = m_itemEdited->GetWidth(),
 366         h = m_itemEdited->GetHeight();
 367
 368     int x, y;
 369     m_owner->CalcScrolledPosition(item->GetX(), item->GetY(), &x, &y);
 370
 371     int image_h = 0,
 372         image_w = 0;
 373
 374     int image = item->GetCurrentImage();
 375     if ( image != NO_IMAGE )
 376     {
 377         if ( m_owner->m_imageListNormal )
 378         {
 379             m_owner->m_imageListNormal->GetSize( image, image_w, image_h );
 380             image_w += MARGIN_BETWEEN_IMAGE_AND_TEXT;
 381         }
 382         else
 383         {
 384             wxFAIL_MSG(_T("you must create an image list to use images!"));
 385         }
 386     }
 387
 388     // FIXME: what are all these hardcoded 4, 8 and 11s really?
 389     x += image_w;
 390     w -= image_w + 4;
 391 #ifdef __WXMAC__
 392     wxSize bs = DoGetBestSize() ;
 393     // edit control height
 394     if ( h > bs.y - 8 )
 395     {
 396         int diff = h - ( bs.y - 8 ) ;
 397         h -= diff ;
 398         y += diff / 2 ;
 399     }
 400 #endif
 401
 402     (void)Create(m_owner, wxID_ANY, m_startValue,
 403                  wxPoint(x - 4, y - 4), wxSize(w + 11, h + 8));
 404 }
 405
 406 bool wxTreeTextCtrl::AcceptChanges()
 407 {
 408     const wxString value = GetValue();
 409
 410     if ( value == m_startValue )
 411     {
 412         // nothing changed, always accept
 413         // when an item remains unchanged, the owner
 414         // needs to be notified that the user decided
 415         // not to change the tree item label, and that
 416         // the edit has been cancelled
 417
 418         m_owner->OnRenameCancelled(m_itemEdited);
 419         return true;
 420     }
 421
 422     if ( !m_owner->OnRenameAccept(m_itemEdited, value) )
 423     {
 424         // vetoed by the user
 425         return false;
 426     }
 427
 428     // accepted, do rename the item
 429     m_owner->SetItemText(m_itemEdited, value);
 430
 431     return true;
 432 }
 433
 434 void wxTreeTextCtrl::Finish()
 435 {
 436     if ( !m_finished  )
 437     {
 438         m_owner->ResetTextControl();
 439
 440         wxPendingDelete.Append(this);
 441
 442         m_finished = true;
 443
 444         m_owner->SetFocus();
 445     }
 446 }
 447
 448 void wxTreeTextCtrl::OnChar( wxKeyEvent &event )
 449 {
 450     switch ( event.m_keyCode )
 451     {
 452         case WXK_RETURN:
 453             EndEdit();
 454             break;
 455
 456         case WXK_ESCAPE:
 457             StopEditing();
 458             break;
 459
 460         default:
 461             event.Skip();
 462     }
 463 }
 464
 465 void wxTreeTextCtrl::OnKeyUp( wxKeyEvent &event )
 466 {
 467     if ( !m_finished )
 468     {
 469         // auto-grow the textctrl:
 470         wxSize parentSize = m_owner->GetSize();
 471         wxPoint myPos = GetPosition();
 472         wxSize mySize = GetSize();
 473         int sx, sy;
 474         GetTextExtent(GetValue() + _T("M"), &sx, &sy);
 475         if (myPos.x + sx > parentSize.x)
 476             sx = parentSize.x - myPos.x;
 477         if (mySize.x > sx)
 478             sx = mySize.x;
 479         SetSize(sx, wxDefaultCoord);
 480     }
 481
 482     event.Skip();
 483 }
 484
 485 void wxTreeTextCtrl::OnKillFocus( wxFocusEvent &event )
 486 {
 487     if ( !m_finished && !m_aboutToFinish )
 488     {
 489         // We must finish regardless of success, otherwise we'll get
 490         // focus problems:
 491         Finish();
 492
 493         if ( !AcceptChanges() )
 494             m_owner->OnRenameCancelled( m_itemEdited );
 495     }
 496
 497     // We must let the native text control handle focus, too, otherwise
 498     // it could have problems with the cursor (e.g., in wxGTK).
 499     event.Skip();
 500 }
 501
 502 // -----------------------------------------------------------------------------
 503 // wxGenericTreeItem
 504 // -----------------------------------------------------------------------------
 505
 506 wxGenericTreeItem::wxGenericTreeItem(wxGenericTreeItem *parent,
 507                                      const wxString& text,
 508                                      int image, int selImage,
 509                                      wxTreeItemData *data)
 510                  : m_text(text)
 511 {
 512     m_images[wxTreeItemIcon_Normal] = image;
 513     m_images[wxTreeItemIcon_Selected] = selImage;
 514     m_images[wxTreeItemIcon_Expanded] = NO_IMAGE;
 515     m_images[wxTreeItemIcon_SelectedExpanded] = NO_IMAGE;
 516
 517     m_data = data;
 518     m_x = m_y = 0;
 519
 520     m_isCollapsed = true;
 521     m_hasHilight = false;
 522     m_hasPlus = false;
 523     m_isBold = false;
 524
 525     m_parent = parent;
 526
 527     m_attr = (wxTreeItemAttr *)NULL;
 528     m_ownsAttr = false;
 529
 530     // We don't know the height here yet.
 531     m_width = 0;
 532     m_height = 0;
 533 }
 534
 535 wxGenericTreeItem::~wxGenericTreeItem()
 536 {
 537     delete m_data;
 538
 539     if (m_ownsAttr) delete m_attr;
 540
 541     wxASSERT_MSG( m_children.IsEmpty(),
 542                   wxT("please call DeleteChildren() before deleting the item") );
 543 }
 544
 545 void wxGenericTreeItem::DeleteChildren(wxGenericTreeCtrl *tree)
 546 {
 547     size_t count = m_children.Count();
 548     for ( size_t n = 0; n < count; n++ )
 549     {
 550         wxGenericTreeItem *child = m_children[n];
 551         if (tree)
 552             tree->SendDeleteEvent(child);
 553
 554         child->DeleteChildren(tree);
 555         if (child == tree->m_select_me)
 556             tree->m_select_me = NULL;
 557         delete child;
 558     }
 559
 560     m_children.Empty();
 561 }
 562
 563 void wxGenericTreeItem::SetText( const wxString &text )
 564 {
 565     m_text = text;
 566 }
 567
 568 size_t wxGenericTreeItem::GetChildrenCount(bool recursively) const
 569 {
 570     size_t count = m_children.Count();
 571     if ( !recursively )
 572         return count;
 573
 574     size_t total = count;
 575     for (size_t n = 0; n < count; ++n)
 576     {
 577         total += m_children[n]->GetChildrenCount();
 578     }
 579
 580     return total;
 581 }
 582
 583 void wxGenericTreeItem::GetSize( int &x, int &y,
 584                                  const wxGenericTreeCtrl *theButton )
 585 {
 586     int bottomY=m_y+theButton->GetLineHeight(this);
 587     if ( y < bottomY ) y = bottomY;
 588     int width = m_x +  m_width;
 589     if ( x < width ) x = width;
 590
 591     if (IsExpanded())
 592     {
 593         size_t count = m_children.Count();
 594         for ( size_t n = 0; n < count; ++n )
 595         {
 596             m_children[n]->GetSize( x, y, theButton );
 597         }
 598     }
 599 }
 600
 601 wxGenericTreeItem *wxGenericTreeItem::HitTest(const wxPoint& point,
 602                                               const wxGenericTreeCtrl *theCtrl,
 603                                               int &flags,
 604                                               int level)
 605 {
 606     // for a hidden root node, don't evaluate it, but do evaluate children
 607     if ( !(level == 0 && theCtrl->HasFlag(wxTR_HIDE_ROOT)) )
 608     {
 609         // evaluate the item
 610         int h = theCtrl->GetLineHeight(this);
 611         if ((point.y > m_y) && (point.y < m_y + h))
 612         {
 613             int y_mid = m_y + h/2;
 614             if (point.y < y_mid )
 615                 flags |= wxTREE_HITTEST_ONITEMUPPERPART;
 616             else
 617                 flags |= wxTREE_HITTEST_ONITEMLOWERPART;
 618
 619             int xCross = m_x - theCtrl->GetSpacing();
 620 #ifdef __WXMAC__
 621             // according to the drawing code the triangels are drawn
 622             // at -4 , -4  from the position up to +10/+10 max
 623             if ((point.x > xCross-4) && (point.x < xCross+10) &&
 624                 (point.y > y_mid-4) && (point.y < y_mid+10) &&
 625                 HasPlus() && theCtrl->HasButtons() )
 626 #else
 627             // 5 is the size of the plus sign
 628             if ((point.x > xCross-6) && (point.x < xCross+6) &&
 629                 (point.y > y_mid-6) && (point.y < y_mid+6) &&
 630                 HasPlus() && theCtrl->HasButtons() )
 631 #endif
 632             {
 633                 flags |= wxTREE_HITTEST_ONITEMBUTTON;
 634                 return this;
 635             }
 636
 637             if ((point.x >= m_x) && (point.x <= m_x+m_width))
 638             {
 639                 int image_w = -1;
 640                 int image_h;
 641
 642                 // assuming every image (normal and selected) has the same size!
 643                 if ( (GetImage() != NO_IMAGE) && theCtrl->m_imageListNormal )
 644                     theCtrl->m_imageListNormal->GetSize(GetImage(),
 645                                                         image_w, image_h);
 646
 647                 if ((image_w != -1) && (point.x <= m_x + image_w + 1))
 648                     flags |= wxTREE_HITTEST_ONITEMICON;
 649                 else
 650                     flags |= wxTREE_HITTEST_ONITEMLABEL;
 651
 652                 return this;
 653             }
 654
 655             if (point.x < m_x)
 656                 flags |= wxTREE_HITTEST_ONITEMINDENT;
 657             if (point.x > m_x+m_width)
 658                 flags |= wxTREE_HITTEST_ONITEMRIGHT;
 659
 660             return this;
 661         }
 662
 663         // if children are expanded, fall through to evaluate them
 664         if (m_isCollapsed) return (wxGenericTreeItem*) NULL;
 665     }
 666
 667     // evaluate children
 668     size_t count = m_children.Count();
 669     for ( size_t n = 0; n < count; n++ )
 670     {
 671         wxGenericTreeItem *res = m_children[n]->HitTest( point,
 672                                                          theCtrl,
 673                                                          flags,
 674                                                          level + 1 );
 675         if ( res != NULL )
 676             return res;
 677     }
 678
 679     return (wxGenericTreeItem*) NULL;
 680 }
 681
 682 int wxGenericTreeItem::GetCurrentImage() const
 683 {
 684     int image = NO_IMAGE;
 685     if ( IsExpanded() )
 686     {
 687         if ( IsSelected() )
 688         {
 689             image = GetImage(wxTreeItemIcon_SelectedExpanded);
 690         }
 691
 692         if ( image == NO_IMAGE )
 693         {
 694             // we usually fall back to the normal item, but try just the
 695             // expanded one (and not selected) first in this case
 696             image = GetImage(wxTreeItemIcon_Expanded);
 697         }
 698     }
 699     else // not expanded
 700     {
 701         if ( IsSelected() )
 702             image = GetImage(wxTreeItemIcon_Selected);
 703     }
 704
 705     // maybe it doesn't have the specific image we want,
 706     // try the default one instead
 707     if ( image == NO_IMAGE ) image = GetImage();
 708
 709     return image;
 710 }
 711
 712 // -----------------------------------------------------------------------------
 713 // wxGenericTreeCtrl implementation
 714 // -----------------------------------------------------------------------------
 715
 716 IMPLEMENT_DYNAMIC_CLASS(wxGenericTreeCtrl, wxControl)
 717
 718 BEGIN_EVENT_TABLE(wxGenericTreeCtrl, wxTreeCtrlBase)
 719     EVT_PAINT          (wxGenericTreeCtrl::OnPaint)
 720     EVT_MOUSE_EVENTS   (wxGenericTreeCtrl::OnMouse)
 721     EVT_CHAR           (wxGenericTreeCtrl::OnChar)
 722     EVT_SET_FOCUS      (wxGenericTreeCtrl::OnSetFocus)
 723     EVT_KILL_FOCUS     (wxGenericTreeCtrl::OnKillFocus)
 724     EVT_TREE_ITEM_GETTOOLTIP(wxID_ANY, wxGenericTreeCtrl::OnGetToolTip)
 725 END_EVENT_TABLE()
 726
 727 #if !defined(__WXMSW__) || defined(__WXUNIVERSAL__)
 728 /*
 729  * wxTreeCtrl has to be a real class or we have problems with
 730  * the run-time information.
 731  */
 732
 733 IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxGenericTreeCtrl)
 734 #endif
 735
 736 // -----------------------------------------------------------------------------
 737 // construction/destruction
 738 // -----------------------------------------------------------------------------
 739
 740 void wxGenericTreeCtrl::Init()
 741 {
 742     m_current =
 743     m_key_current =
 744     m_anchor =
 745     m_select_me = (wxGenericTreeItem *) NULL;
 746     m_hasFocus = false;
 747     m_dirty = false;
 748
 749     m_lineHeight = 10;
 750     m_indent = 15;
 751     m_spacing = 18;
 752
 753     m_hilightBrush = new wxBrush
 754                          (
 755                             wxSystemSettings::GetColour
 756                             (
 757                                 wxSYS_COLOUR_HIGHLIGHT
 758                             ),
 759                             wxSOLID
 760                          );
 761
 762     m_hilightUnfocusedBrush = new wxBrush
 763                               (
 764                                  wxSystemSettings::GetColour
 765                                  (
 766                                      wxSYS_COLOUR_BTNSHADOW
 767                                  ),
 768                                  wxSOLID
 769                               );
 770
 771     m_imageListButtons = NULL;
 772     m_ownsImageListButtons = false;
 773
 774     m_dragCount = 0;
 775     m_isDragging = false;
 776     m_dropTarget = m_oldSelection = NULL;
 777     m_underMouse = NULL;
 778     m_textCtrl = NULL;
 779
 780     m_renameTimer = NULL;
 781     m_freezeCount = 0;
 782
 783     m_findTimer = NULL;
 784
 785     m_dropEffectAboveItem = false;
 786
 787     m_lastOnSame = false;
 788
 789 #ifdef __WXMAC_CARBON__
 790     m_normalFont.MacCreateThemeFont( kThemeViewsFont ) ;
 791 #else
 792     m_normalFont = wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT );
 793 #endif
 794     m_boldFont = wxFont(m_normalFont.GetPointSize(),
 795                         m_normalFont.GetFamily(),
 796                         m_normalFont.GetStyle(),
 797                         wxBOLD,
 798                         m_normalFont.GetUnderlined(),
 799                         m_normalFont.GetFaceName(),
 800                         m_normalFont.GetEncoding());
 801 }
 802
 803 bool wxGenericTreeCtrl::Create(wxWindow *parent,
 804                                wxWindowID id,
 805                                const wxPoint& pos,
 806                                const wxSize& size,
 807                                long style,
 808                                const wxValidator& validator,
 809                                const wxString& name )
 810 {
 811 #ifdef __WXMAC__
 812     int major,minor;
 813     wxGetOsVersion( &major, &minor );
 814
 815     style &= ~wxTR_LINES_AT_ROOT;
 816     style |= wxTR_NO_LINES;
 817     if (major < 10)
 818         style |= wxTR_ROW_LINES;
 819 #endif // __WXMAC__
 820
 821     if ( !wxControl::Create( parent, id, pos, size,
 822                              style|wxHSCROLL|wxVSCROLL,
 823                              validator,
 824                              name ) )
 825         return false;
 826
 827     // If the tree display has no buttons, but does have
 828     // connecting lines, we can use a narrower layout.
 829     // It may not be a good idea to force this...
 830     if (!HasButtons() && !HasFlag(wxTR_NO_LINES))
 831     {
 832         m_indent= 10;
 833         m_spacing = 10;
 834     }
 835
 836     wxVisualAttributes attr = GetDefaultAttributes();
 837     SetOwnForegroundColour( attr.colFg );
 838     SetOwnBackgroundColour( attr.colBg );
 839     if (!m_hasFont)
 840         SetOwnFont(attr.font);
 841
 842     m_dottedPen = wxPen( wxT("grey"), 0, 0 );
 843
 844     SetBestSize(size);
 845
 846     return true;
 847 }
 848
 849 wxGenericTreeCtrl::~wxGenericTreeCtrl()
 850 {
 851     delete m_hilightBrush;
 852     delete m_hilightUnfocusedBrush;
 853
 854     DeleteAllItems();
 855
 856     delete m_renameTimer;
 857     delete m_findTimer;
 858
 859     if (m_ownsImageListButtons)
 860         delete m_imageListButtons;
 861 }
 862
 863 // -----------------------------------------------------------------------------
 864 // accessors
 865 // -----------------------------------------------------------------------------
 866
 867 size_t wxGenericTreeCtrl::GetCount() const
 868 {
 869     if ( !m_anchor )
 870     {
 871         // the tree is empty
 872         return 0;
 873     }
 874
 875     size_t count = m_anchor->GetChildrenCount();
 876     if ( !HasFlag(wxTR_HIDE_ROOT) )
 877     {
 878         // take the root itself into account
 879         count++;
 880     }
 881
 882     return count;
 883 }
 884
 885 void wxGenericTreeCtrl::SetIndent(unsigned int indent)
 886 {
 887     m_indent = (unsigned short) indent;
 888     m_dirty = true;
 889 }
 890
 891 size_t
 892 wxGenericTreeCtrl::GetChildrenCount(const wxTreeItemId& item,
 893                                     bool recursively) const
 894 {
 895     wxCHECK_MSG( item.IsOk(), 0u, wxT("invalid tree item") );
 896
 897     return ((wxGenericTreeItem*) item.m_pItem)->GetChildrenCount(recursively);
 898 }
 899
 900 void wxGenericTreeCtrl::SetWindowStyle(const long styles)
 901 {
 902     // Do not try to expand the root node if it hasn't been created yet
 903     if (m_anchor && !HasFlag(wxTR_HIDE_ROOT) && (styles & wxTR_HIDE_ROOT))
 904     {
 905         // if we will hide the root, make sure children are visible
 906         m_anchor->SetHasPlus();
 907         m_anchor->Expand();
 908         CalculatePositions();
 909     }
 910
 911     // right now, just sets the styles.  Eventually, we may
 912     // want to update the inherited styles, but right now
 913     // none of the parents has updatable styles
 914     m_windowStyle = styles;
 915     m_dirty = true;
 916 }
 917
 918 // -----------------------------------------------------------------------------
 919 // functions to work with tree items
 920 // -----------------------------------------------------------------------------
 921
 922 wxString wxGenericTreeCtrl::GetItemText(const wxTreeItemId& item) const
 923 {
 924     wxCHECK_MSG( item.IsOk(), wxEmptyString, wxT("invalid tree item") );
 925
 926     return ((wxGenericTreeItem*) item.m_pItem)->GetText();
 927 }
 928
 929 int wxGenericTreeCtrl::GetItemImage(const wxTreeItemId& item,
 930                              wxTreeItemIcon which) const
 931 {
 932     wxCHECK_MSG( item.IsOk(), -1, wxT("invalid tree item") );
 933
 934     return ((wxGenericTreeItem*) item.m_pItem)->GetImage(which);
 935 }
 936
 937 wxTreeItemData *wxGenericTreeCtrl::GetItemData(const wxTreeItemId& item) const
 938 {
 939     wxCHECK_MSG( item.IsOk(), NULL, wxT("invalid tree item") );
 940
 941     return ((wxGenericTreeItem*) item.m_pItem)->GetData();
 942 }
 943
 944 wxColour wxGenericTreeCtrl::GetItemTextColour(const wxTreeItemId& item) const
 945 {
 946     wxCHECK_MSG( item.IsOk(), wxNullColour, wxT("invalid tree item") );
 947
 948     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
 949     return pItem->Attr().GetTextColour();
 950 }
 951
 952 wxColour wxGenericTreeCtrl::GetItemBackgroundColour(const wxTreeItemId& item) const
 953 {
 954     wxCHECK_MSG( item.IsOk(), wxNullColour, wxT("invalid tree item") );
 955
 956     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
 957     return pItem->Attr().GetBackgroundColour();
 958 }
 959
 960 wxFont wxGenericTreeCtrl::GetItemFont(const wxTreeItemId& item) const
 961 {
 962     wxCHECK_MSG( item.IsOk(), wxNullFont, wxT("invalid tree item") );
 963
 964     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
 965     return pItem->Attr().GetFont();
 966 }
 967
 968 void wxGenericTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text)
 969 {
 970     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
 971
 972     wxClientDC dc(this);
 973     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
 974     pItem->SetText(text);
 975     CalculateSize(pItem, dc);
 976     RefreshLine(pItem);
 977 }
 978
 979 void wxGenericTreeCtrl::SetItemImage(const wxTreeItemId& item,
 980                               int image,
 981                               wxTreeItemIcon which)
 982 {
 983     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
 984
 985     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
 986     pItem->SetImage(image, which);
 987
 988     wxClientDC dc(this);
 989     CalculateSize(pItem, dc);
 990     RefreshLine(pItem);
 991 }
 992
 993 void wxGenericTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data)
 994 {
 995     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
 996
 997     if (data)
 998         data->SetId( item );
 999
1000     ((wxGenericTreeItem*) item.m_pItem)->SetData(data);
1001 }
1002
1003 void wxGenericTreeCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
1004 {
1005     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1006
1007     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
1008     pItem->SetHasPlus(has);
1009     RefreshLine(pItem);
1010 }
1011
1012 void wxGenericTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
1013 {
1014     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1015
1016     // avoid redrawing the tree if no real change
1017     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
1018     if ( pItem->IsBold() != bold )
1019     {
1020         pItem->SetBold(bold);
1021         RefreshLine(pItem);
1022     }
1023 }
1024
1025 void wxGenericTreeCtrl::SetItemDropHighlight(const wxTreeItemId& item,
1026                                              bool highlight)
1027 {
1028     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1029
1030     wxColour fg, bg;
1031
1032     if (highlight)
1033     {
1034         bg = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
1035         fg = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
1036     }
1037
1038     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
1039     pItem->Attr().SetTextColour(fg);
1040     pItem->Attr().SetBackgroundColour(bg);
1041     RefreshLine(pItem);
1042 }
1043
1044 void wxGenericTreeCtrl::SetItemTextColour(const wxTreeItemId& item,
1045                                    const wxColour& col)
1046 {
1047     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1048
1049     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
1050     pItem->Attr().SetTextColour(col);
1051     RefreshLine(pItem);
1052 }
1053
1054 void wxGenericTreeCtrl::SetItemBackgroundColour(const wxTreeItemId& item,
1055                                          const wxColour& col)
1056 {
1057     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1058
1059     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
1060     pItem->Attr().SetBackgroundColour(col);
1061     RefreshLine(pItem);
1062 }
1063
1064 void wxGenericTreeCtrl::SetItemFont(const wxTreeItemId& item, const wxFont& font)
1065 {
1066     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1067
1068     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
1069     pItem->Attr().SetFont(font);
1070     RefreshLine(pItem);
1071 }
1072
1073 bool wxGenericTreeCtrl::SetFont( const wxFont &font )
1074 {
1075     wxTreeCtrlBase::SetFont(font);
1076
1077     m_normalFont = font ;
1078     m_boldFont = wxFont(m_normalFont.GetPointSize(),
1079                         m_normalFont.GetFamily(),
1080                         m_normalFont.GetStyle(),
1081                         wxBOLD,
1082                         m_normalFont.GetUnderlined(),
1083                         m_normalFont.GetFaceName(),
1084                         m_normalFont.GetEncoding());
1085
1086     return true;
1087 }
1088
1089
1090 // -----------------------------------------------------------------------------
1091 // item status inquiries
1092 // -----------------------------------------------------------------------------
1093
1094 bool wxGenericTreeCtrl::IsVisible(const wxTreeItemId& item) const
1095 {
1096     wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
1097
1098     // An item is only visible if it's not a descendant of a collapsed item
1099     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
1100     wxGenericTreeItem* parent = pItem->GetParent();
1101     while (parent)
1102     {
1103         if (!parent->IsExpanded())
1104             return false;
1105         parent = parent->GetParent();
1106     }
1107
1108     int startX, startY;
1109     GetViewStart(& startX, & startY);
1110
1111     wxSize clientSize = GetClientSize();
1112
1113     wxRect rect;
1114     if (!GetBoundingRect(item, rect))
1115         return false;
1116     if (rect.GetWidth() == 0 || rect.GetHeight() == 0)
1117         return false;
1118     if (rect.GetBottom() < 0 || rect.GetTop() > clientSize.y)
1119         return false;
1120     if (rect.GetRight() < 0 || rect.GetLeft() > clientSize.x)
1121         return false;
1122
1123     return true;
1124 }
1125
1126 bool wxGenericTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const
1127 {
1128     wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
1129
1130     // consider that the item does have children if it has the "+" button: it
1131     // might not have them (if it had never been expanded yet) but then it
1132     // could have them as well and it's better to err on this side rather than
1133     // disabling some operations which are restricted to the items with
1134     // children for an item which does have them
1135     return ((wxGenericTreeItem*) item.m_pItem)->HasPlus();
1136 }
1137
1138 bool wxGenericTreeCtrl::IsExpanded(const wxTreeItemId& item) const
1139 {
1140     wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
1141
1142     return ((wxGenericTreeItem*) item.m_pItem)->IsExpanded();
1143 }
1144
1145 bool wxGenericTreeCtrl::IsSelected(const wxTreeItemId& item) const
1146 {
1147     wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
1148
1149     return ((wxGenericTreeItem*) item.m_pItem)->IsSelected();
1150 }
1151
1152 bool wxGenericTreeCtrl::IsBold(const wxTreeItemId& item) const
1153 {
1154     wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
1155
1156     return ((wxGenericTreeItem*) item.m_pItem)->IsBold();
1157 }
1158
1159 // -----------------------------------------------------------------------------
1160 // navigation
1161 // -----------------------------------------------------------------------------
1162
1163 wxTreeItemId wxGenericTreeCtrl::GetItemParent(const wxTreeItemId& item) const
1164 {
1165     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1166
1167     return ((wxGenericTreeItem*) item.m_pItem)->GetParent();
1168 }
1169
1170 wxTreeItemId wxGenericTreeCtrl::GetFirstChild(const wxTreeItemId& item,
1171                                               wxTreeItemIdValue& cookie) const
1172 {
1173     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1174
1175     cookie = 0;
1176     return GetNextChild(item, cookie);
1177 }
1178
1179 wxTreeItemId wxGenericTreeCtrl::GetNextChild(const wxTreeItemId& item,
1180                                              wxTreeItemIdValue& cookie) const
1181 {
1182     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1183
1184     wxArrayGenericTreeItems& children = ((wxGenericTreeItem*) item.m_pItem)->GetChildren();
1185
1186     // it's ok to cast cookie to size_t, we never have indices big enough to
1187     // overflow "void *"
1188     size_t *pIndex = (size_t *)&cookie;
1189     if ( *pIndex < children.Count() )
1190     {
1191         return children.Item((*pIndex)++);
1192     }
1193     else
1194     {
1195         // there are no more of them
1196         return wxTreeItemId();
1197     }
1198 }
1199
1200 #if WXWIN_COMPATIBILITY_2_4
1201
1202 wxTreeItemId wxGenericTreeCtrl::GetFirstChild(const wxTreeItemId& item,
1203                                               long& cookie) const
1204 {
1205     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1206
1207     cookie = 0;
1208     return GetNextChild(item, cookie);
1209 }
1210
1211 wxTreeItemId wxGenericTreeCtrl::GetNextChild(const wxTreeItemId& item,
1212                                              long& cookie) const
1213 {
1214     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1215
1216     wxArrayGenericTreeItems& children = ((wxGenericTreeItem*) item.m_pItem)->GetChildren();
1217     if ( (size_t)cookie < children.Count() )
1218     {
1219         return children.Item((size_t)cookie++);
1220     }
1221     else
1222     {
1223         // there are no more of them
1224         return wxTreeItemId();
1225     }
1226 }
1227
1228 #endif // WXWIN_COMPATIBILITY_2_4
1229
1230 wxTreeItemId wxGenericTreeCtrl::GetLastChild(const wxTreeItemId& item) const
1231 {
1232     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1233
1234     wxArrayGenericTreeItems& children = ((wxGenericTreeItem*) item.m_pItem)->GetChildren();
1235     return (children.IsEmpty() ? wxTreeItemId() : wxTreeItemId(children.Last()));
1236 }
1237
1238 wxTreeItemId wxGenericTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
1239 {
1240     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1241
1242     wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
1243     wxGenericTreeItem *parent = i->GetParent();
1244     if ( parent == NULL )
1245     {
1246         // root item doesn't have any siblings
1247         return wxTreeItemId();
1248     }
1249
1250     wxArrayGenericTreeItems& siblings = parent->GetChildren();
1251     int index = siblings.Index(i);
1252     wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
1253
1254     size_t n = (size_t)(index + 1);
1255     return n == siblings.Count() ? wxTreeItemId() : wxTreeItemId(siblings[n]);
1256 }
1257
1258 wxTreeItemId wxGenericTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const
1259 {
1260     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1261
1262     wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
1263     wxGenericTreeItem *parent = i->GetParent();
1264     if ( parent == NULL )
1265     {
1266         // root item doesn't have any siblings
1267         return wxTreeItemId();
1268     }
1269
1270     wxArrayGenericTreeItems& siblings = parent->GetChildren();
1271     int index = siblings.Index(i);
1272     wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
1273
1274     return index == 0 ? wxTreeItemId()
1275                       : wxTreeItemId(siblings[(size_t)(index - 1)]);
1276 }
1277
1278 // Only for internal use right now, but should probably be public
1279 wxTreeItemId wxGenericTreeCtrl::GetNext(const wxTreeItemId& item) const
1280 {
1281     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1282
1283     wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
1284
1285     // First see if there are any children.
1286     wxArrayGenericTreeItems& children = i->GetChildren();
1287     if (children.GetCount() > 0)
1288     {
1289          return children.Item(0);
1290     }
1291     else
1292     {
1293          // Try a sibling of this or ancestor instead
1294          wxTreeItemId p = item;
1295          wxTreeItemId toFind;
1296          do
1297          {
1298               toFind = GetNextSibling(p);
1299               p = GetItemParent(p);
1300          } while (p.IsOk() && !toFind.IsOk());
1301          return toFind;
1302     }
1303 }
1304
1305 wxTreeItemId wxGenericTreeCtrl::GetFirstVisibleItem() const
1306 {
1307     wxTreeItemId id = GetRootItem();
1308     if (!id.IsOk())
1309         return id;
1310
1311     do
1312     {
1313         if (IsVisible(id))
1314               return id;
1315         id = GetNext(id);
1316     } while (id.IsOk());
1317
1318     return wxTreeItemId();
1319 }
1320
1321 wxTreeItemId wxGenericTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
1322 {
1323     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1324
1325     wxTreeItemId id = item;
1326     if (id.IsOk())
1327     {
1328         while (id = GetNext(id), id.IsOk())
1329         {
1330             if (IsVisible(id))
1331                 return id;
1332         }
1333     }
1334     return wxTreeItemId();
1335 }
1336
1337 wxTreeItemId wxGenericTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
1338 {
1339     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1340
1341     wxFAIL_MSG(wxT("not implemented"));
1342
1343     return wxTreeItemId();
1344 }
1345
1346 // called by wxTextTreeCtrl when it marks itself for deletion
1347 void wxGenericTreeCtrl::ResetTextControl()
1348 {
1349     m_textCtrl = NULL;
1350 }
1351
1352 // find the first item starting with the given prefix after the given item
1353 wxTreeItemId wxGenericTreeCtrl::FindItem(const wxTreeItemId& idParent,
1354                                          const wxString& prefixOrig) const
1355 {
1356     // match is case insensitive as this is more convenient to the user: having
1357     // to press Shift-letter to go to the item starting with a capital letter
1358     // would be too bothersome
1359     wxString prefix = prefixOrig.Lower();
1360
1361     // determine the starting point: we shouldn't take the current item (this
1362     // allows to switch between two items starting with the same letter just by
1363     // pressing it) but we shouldn't jump to the next one if the user is
1364     // continuing to type as otherwise he might easily skip the item he wanted
1365     wxTreeItemId id = idParent;
1366     if ( prefix.length() == 1 )
1367     {
1368         id = GetNext(id);
1369     }
1370
1371     // look for the item starting with the given prefix after it
1372     while ( id.IsOk() && !GetItemText(id).Lower().StartsWith(prefix) )
1373     {
1374         id = GetNext(id);
1375     }
1376
1377     // if we haven't found anything...
1378     if ( !id.IsOk() )
1379     {
1380         // ... wrap to the beginning
1381         id = GetRootItem();
1382         if ( HasFlag(wxTR_HIDE_ROOT) )
1383         {
1384             // can't select virtual root
1385             id = GetNext(id);
1386         }
1387
1388         // and try all the items (stop when we get to the one we started from)
1389         while ( id != idParent && !GetItemText(id).Lower().StartsWith(prefix) )
1390         {
1391             id = GetNext(id);
1392         }
1393     }
1394
1395     return id;
1396 }
1397
1398 // -----------------------------------------------------------------------------
1399 // operations
1400 // -----------------------------------------------------------------------------
1401
1402 wxTreeItemId wxGenericTreeCtrl::DoInsertItem(const wxTreeItemId& parentId,
1403                                              size_t previous,
1404                                              const wxString& text,
1405                                              int image,
1406                                              int selImage,
1407                                              wxTreeItemData *data)
1408 {
1409     wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem;
1410     if ( !parent )
1411     {
1412         // should we give a warning here?
1413         return AddRoot(text, image, selImage, data);
1414     }
1415
1416     m_dirty = true;     // do this first so stuff below doesn't cause flicker
1417
1418     wxGenericTreeItem *item =
1419         new wxGenericTreeItem( parent, text, image, selImage, data );
1420
1421     if ( data != NULL )
1422     {
1423         data->m_pItem = item;
1424     }
1425
1426     parent->Insert( item, previous == (size_t)-1 ? parent->GetChildren().size()
1427                                                  : previous );
1428
1429     return item;
1430 }
1431
1432 wxTreeItemId wxGenericTreeCtrl::AddRoot(const wxString& text,
1433                                         int image,
1434                                         int selImage,
1435                                         wxTreeItemData *data)
1436 {
1437     wxCHECK_MSG( !m_anchor, wxTreeItemId(), wxT("tree can have only one root") );
1438
1439     m_dirty = true;     // do this first so stuff below doesn't cause flicker
1440
1441     m_anchor = new wxGenericTreeItem((wxGenericTreeItem *)NULL, text,
1442                                    image, selImage, data);
1443     if ( data != NULL )
1444     {
1445         data->m_pItem = m_anchor;
1446     }
1447
1448     if (HasFlag(wxTR_HIDE_ROOT))
1449     {
1450         // if root is hidden, make sure we can navigate
1451         // into children
1452         m_anchor->SetHasPlus();
1453         m_anchor->Expand();
1454         CalculatePositions();
1455     }
1456
1457     if (!HasFlag(wxTR_MULTIPLE))
1458     {
1459         m_current = m_key_current = m_anchor;
1460         m_current->SetHilight( true );
1461     }
1462
1463     return m_anchor;
1464 }
1465
1466 wxTreeItemId wxGenericTreeCtrl::DoInsertAfter(const wxTreeItemId& parentId,
1467                                               const wxTreeItemId& idPrevious,
1468                                               const wxString& text,
1469                                               int image, int selImage,
1470                                               wxTreeItemData *data)
1471 {
1472     wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem;
1473     if ( !parent )
1474     {
1475         // should we give a warning here?
1476         return AddRoot(text, image, selImage, data);
1477     }
1478
1479     int index = -1;
1480     if (idPrevious.IsOk())
1481     {
1482         index = parent->GetChildren().Index((wxGenericTreeItem*) idPrevious.m_pItem);
1483         wxASSERT_MSG( index != wxNOT_FOUND,
1484                       wxT("previous item in wxGenericTreeCtrl::InsertItem() is not a sibling") );
1485     }
1486
1487     return DoInsertItem(parentId, (size_t)++index, text, image, selImage, data);
1488 }
1489
1490
1491 void wxGenericTreeCtrl::SendDeleteEvent(wxGenericTreeItem *item)
1492 {
1493     wxTreeEvent event( wxEVT_COMMAND_TREE_DELETE_ITEM, GetId() );
1494     event.m_item = item;
1495     event.SetEventObject( this );
1496     ProcessEvent( event );
1497 }
1498
1499 // Don't leave edit or selection on a child which is about to disappear
1500 void wxGenericTreeCtrl::ChildrenClosing(wxGenericTreeItem* item)
1501 {
1502     if (m_textCtrl != NULL && item != m_textCtrl->item() && IsDescendantOf(item, m_textCtrl->item())) {
1503         m_textCtrl->StopEditing();
1504     }
1505     if (item != m_key_current && IsDescendantOf(item, m_key_current)) {
1506         m_key_current = NULL;
1507     }
1508     if (IsDescendantOf(item, m_select_me)) {
1509         m_select_me = item;
1510     }
1511     if (item != m_current && IsDescendantOf(item, m_current)) {
1512         m_current->SetHilight( false );
1513         m_current = NULL;
1514         m_select_me = item;
1515     }
1516 }
1517
1518 void wxGenericTreeCtrl::DeleteChildren(const wxTreeItemId& itemId)
1519 {
1520     m_dirty = true;     // do this first so stuff below doesn't cause flicker
1521
1522     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1523     ChildrenClosing(item);
1524     item->DeleteChildren(this);
1525 }
1526
1527 void wxGenericTreeCtrl::Delete(const wxTreeItemId& itemId)
1528 {
1529     m_dirty = true;     // do this first so stuff below doesn't cause flicker
1530
1531     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1532
1533     if (m_textCtrl != NULL && IsDescendantOf(item, m_textCtrl->item()))
1534     {
1535         // can't delete the item being edited, cancel editing it first
1536         m_textCtrl->StopEditing();
1537     }
1538
1539     wxGenericTreeItem *parent = item->GetParent();
1540
1541     // don't keep stale pointers around!
1542     if ( IsDescendantOf(item, m_key_current) )
1543     {
1544         // Don't silently change the selection:
1545         // do it properly in idle time, so event
1546         // handlers get called.
1547
1548         // m_key_current = parent;
1549         m_key_current = NULL;
1550     }
1551
1552     // m_select_me records whether we need to select
1553     // a different item, in idle time.
1554     if ( m_select_me && IsDescendantOf(item, m_select_me) )
1555     {
1556         m_select_me = parent;
1557     }
1558
1559     if ( IsDescendantOf(item, m_current) )
1560     {
1561         // Don't silently change the selection:
1562         // do it properly in idle time, so event
1563         // handlers get called.
1564
1565         // m_current = parent;
1566         m_current = NULL;
1567         m_select_me = parent;
1568     }
1569
1570     // remove the item from the tree
1571     if ( parent )
1572     {
1573         parent->GetChildren().Remove( item );  // remove by value
1574     }
1575     else // deleting the root
1576     {
1577         // nothing will be left in the tree
1578         m_anchor = NULL;
1579     }
1580
1581     // and delete all of its children and the item itself now
1582     item->DeleteChildren(this);
1583     SendDeleteEvent(item);
1584
1585     if (item == m_select_me)
1586         m_select_me = NULL;
1587
1588     delete item;
1589 }
1590
1591 void wxGenericTreeCtrl::DeleteAllItems()
1592 {
1593     if ( m_anchor )
1594     {
1595         Delete(m_anchor);
1596     }
1597 }
1598
1599 void wxGenericTreeCtrl::Expand(const wxTreeItemId& itemId)
1600 {
1601     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1602
1603     wxCHECK_RET( item, _T("invalid item in wxGenericTreeCtrl::Expand") );
1604     wxCHECK_RET( !HasFlag(wxTR_HIDE_ROOT) || itemId != GetRootItem(),
1605                  _T("can't expand hidden root") );
1606
1607     if ( !item->HasPlus() )
1608         return;
1609
1610     if ( item->IsExpanded() )
1611         return;
1612
1613     wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_EXPANDING, GetId() );
1614     event.m_item = item;
1615     event.SetEventObject( this );
1616
1617     if ( ProcessEvent( event ) && !event.IsAllowed() )
1618     {
1619         // cancelled by program
1620         return;
1621     }
1622
1623     item->Expand();
1624     CalculatePositions();
1625
1626     RefreshSubtree(item);
1627
1628     event.SetEventType(wxEVT_COMMAND_TREE_ITEM_EXPANDED);
1629     ProcessEvent( event );
1630 }
1631
1632 void wxGenericTreeCtrl::ExpandAll(const wxTreeItemId& item)
1633 {
1634     if ( !HasFlag(wxTR_HIDE_ROOT) || item != GetRootItem())
1635     {
1636         Expand(item);
1637         if ( !IsExpanded(item) )
1638             return;
1639     }
1640
1641     wxTreeItemIdValue cookie;
1642     wxTreeItemId child = GetFirstChild(item, cookie);
1643     while ( child.IsOk() )
1644     {
1645         ExpandAll(child);
1646
1647         child = GetNextChild(item, cookie);
1648     }
1649 }
1650
1651 void wxGenericTreeCtrl::Collapse(const wxTreeItemId& itemId)
1652 {
1653     wxCHECK_RET( !HasFlag(wxTR_HIDE_ROOT) || itemId != GetRootItem(),
1654                  _T("can't collapse hidden root") );
1655
1656     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1657
1658     if ( !item->IsExpanded() )
1659         return;
1660
1661     wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_COLLAPSING, GetId() );
1662     event.m_item = item;
1663     event.SetEventObject( this );
1664     if ( ProcessEvent( event ) && !event.IsAllowed() )
1665     {
1666         // cancelled by program
1667         return;
1668     }
1669
1670     ChildrenClosing(item);
1671     item->Collapse();
1672
1673 #if 0  // TODO why should items be collapsed recursively?
1674     wxArrayGenericTreeItems& children = item->GetChildren();
1675     size_t count = children.Count();
1676     for ( size_t n = 0; n < count; n++ )
1677     {
1678         Collapse(children[n]);
1679     }
1680 #endif
1681
1682     CalculatePositions();
1683
1684     RefreshSubtree(item);
1685
1686     event.SetEventType(wxEVT_COMMAND_TREE_ITEM_COLLAPSED);
1687     ProcessEvent( event );
1688 }
1689
1690 void wxGenericTreeCtrl::CollapseAndReset(const wxTreeItemId& item)
1691 {
1692     Collapse(item);
1693     DeleteChildren(item);
1694 }
1695
1696 void wxGenericTreeCtrl::Toggle(const wxTreeItemId& itemId)
1697 {
1698     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1699
1700     if (item->IsExpanded())
1701         Collapse(itemId);
1702     else
1703         Expand(itemId);
1704 }
1705
1706 void wxGenericTreeCtrl::Unselect()
1707 {
1708     if (m_current)
1709     {
1710         m_current->SetHilight( false );
1711         RefreshLine( m_current );
1712
1713         m_current = NULL;
1714         m_select_me = NULL;
1715     }
1716 }
1717
1718 void wxGenericTreeCtrl::UnselectAllChildren(wxGenericTreeItem *item)
1719 {
1720     if (item->IsSelected())
1721     {
1722         item->SetHilight(false);
1723         RefreshLine(item);
1724     }
1725
1726     if (item->HasChildren())
1727     {
1728         wxArrayGenericTreeItems& children = item->GetChildren();
1729         size_t count = children.Count();
1730         for ( size_t n = 0; n < count; ++n )
1731         {
1732             UnselectAllChildren(children[n]);
1733         }
1734     }
1735 }
1736
1737 void wxGenericTreeCtrl::UnselectAll()
1738 {
1739     wxTreeItemId rootItem = GetRootItem();
1740
1741     // the tree might not have the root item at all
1742     if ( rootItem )
1743     {
1744         UnselectAllChildren((wxGenericTreeItem*) rootItem.m_pItem);
1745     }
1746 }
1747
1748 // Recursive function !
1749 // To stop we must have crt_item<last_item
1750 // Algorithm :
1751 // Tag all next children, when no more children,
1752 // Move to parent (not to tag)
1753 // Keep going... if we found last_item, we stop.
1754 bool wxGenericTreeCtrl::TagNextChildren(wxGenericTreeItem *crt_item, wxGenericTreeItem *last_item, bool select)
1755 {
1756     wxGenericTreeItem *parent = crt_item->GetParent();
1757
1758     if (parent == NULL) // This is root item
1759         return TagAllChildrenUntilLast(crt_item, last_item, select);
1760
1761     wxArrayGenericTreeItems& children = parent->GetChildren();
1762     int index = children.Index(crt_item);
1763     wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
1764
1765     size_t count = children.Count();
1766     for (size_t n=(size_t)(index+1); n<count; ++n)
1767     {
1768         if (TagAllChildrenUntilLast(children[n], last_item, select)) return true;
1769     }
1770
1771     return TagNextChildren(parent, last_item, select);
1772 }
1773
1774 bool wxGenericTreeCtrl::TagAllChildrenUntilLast(wxGenericTreeItem *crt_item, wxGenericTreeItem *last_item, bool select)
1775 {
1776     crt_item->SetHilight(select);
1777     RefreshLine(crt_item);
1778
1779     if (crt_item==last_item)
1780         return true;
1781
1782     if (crt_item->HasChildren())
1783     {
1784         wxArrayGenericTreeItems& children = crt_item->GetChildren();
1785         size_t count = children.Count();
1786         for ( size_t n = 0; n < count; ++n )
1787         {
1788             if (TagAllChildrenUntilLast(children[n], last_item, select))
1789                 return true;
1790         }
1791     }
1792
1793   return false;
1794 }
1795
1796 void wxGenericTreeCtrl::SelectItemRange(wxGenericTreeItem *item1, wxGenericTreeItem *item2)
1797 {
1798     m_select_me = NULL;
1799
1800     // item2 is not necessary after item1
1801     // choice first' and 'last' between item1 and item2
1802     wxGenericTreeItem *first= (item1->GetY()<item2->GetY()) ? item1 : item2;
1803     wxGenericTreeItem *last = (item1->GetY()<item2->GetY()) ? item2 : item1;
1804
1805     bool select = m_current->IsSelected();
1806
1807     if ( TagAllChildrenUntilLast(first,last,select) )
1808         return;
1809
1810     TagNextChildren(first,last,select);
1811 }
1812
1813 void wxGenericTreeCtrl::DoSelectItem(const wxTreeItemId& itemId,
1814                                      bool unselect_others,
1815                                      bool extended_select)
1816 {
1817     wxCHECK_RET( itemId.IsOk(), wxT("invalid tree item") );
1818
1819     m_select_me = NULL;
1820
1821     bool is_single=!(GetWindowStyleFlag() & wxTR_MULTIPLE);
1822     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1823
1824     //wxCHECK_RET( ( (!unselect_others) && is_single),
1825     //           wxT("this is a single selection tree") );
1826
1827     // to keep going anyhow !!!
1828     if (is_single)
1829     {
1830         if (item->IsSelected())
1831             return; // nothing to do
1832         unselect_others = true;
1833         extended_select = false;
1834     }
1835     else if ( unselect_others && item->IsSelected() )
1836     {
1837         // selection change if there is more than one item currently selected
1838         wxArrayTreeItemIds selected_items;
1839         if ( GetSelections(selected_items) == 1 )
1840             return;
1841     }
1842
1843     wxTreeEvent event( wxEVT_COMMAND_TREE_SEL_CHANGING, GetId() );
1844     event.m_item = item;
1845     event.m_itemOld = m_current;
1846     event.SetEventObject( this );
1847     // TODO : Here we don't send any selection mode yet !
1848
1849     if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() )
1850         return;
1851
1852     wxTreeItemId parent = GetItemParent( itemId );
1853     while (parent.IsOk())
1854     {
1855         if (!IsExpanded(parent))
1856             Expand( parent );
1857
1858         parent = GetItemParent( parent );
1859     }
1860
1861     // ctrl press
1862     if (unselect_others)
1863     {
1864         if (is_single) Unselect(); // to speed up thing
1865         else UnselectAll();
1866     }
1867
1868     // shift press
1869     if (extended_select)
1870     {
1871         if ( !m_current )
1872         {
1873             m_current = m_key_current = (wxGenericTreeItem*) GetRootItem().m_pItem;
1874         }
1875
1876         // don't change the mark (m_current)
1877         SelectItemRange(m_current, item);
1878     }
1879     else
1880     {
1881         bool select = true; // the default
1882
1883         // Check if we need to toggle hilight (ctrl mode)
1884         if (!unselect_others)
1885             select=!item->IsSelected();
1886
1887         m_current = m_key_current = item;
1888         m_current->SetHilight(select);
1889         RefreshLine( m_current );
1890     }
1891
1892     // This can cause idle processing to select the root
1893     // if no item is selected, so it must be after the
1894     // selection is set
1895     EnsureVisible( itemId );
1896
1897     event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
1898     GetEventHandler()->ProcessEvent( event );
1899 }
1900
1901 void wxGenericTreeCtrl::SelectItem(const wxTreeItemId& itemId, bool select)
1902 {
1903     if ( select )
1904     {
1905         DoSelectItem(itemId, !HasFlag(wxTR_MULTIPLE));
1906     }
1907     else // deselect
1908     {
1909         wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1910         wxCHECK_RET( item, wxT("SelectItem(): invalid tree item") );
1911
1912         item->SetHilight(false);
1913         RefreshLine(item);
1914     }
1915 }
1916
1917 void wxGenericTreeCtrl::FillArray(wxGenericTreeItem *item,
1918                                   wxArrayTreeItemIds &array) const
1919 {
1920     if ( item->IsSelected() )
1921         array.Add(wxTreeItemId(item));
1922
1923     if ( item->HasChildren() )
1924     {
1925         wxArrayGenericTreeItems& children = item->GetChildren();
1926         size_t count = children.GetCount();
1927         for ( size_t n = 0; n < count; ++n )
1928             FillArray(children[n], array);
1929     }
1930 }
1931
1932 size_t wxGenericTreeCtrl::GetSelections(wxArrayTreeItemIds &array) const
1933 {
1934     array.Empty();
1935     wxTreeItemId idRoot = GetRootItem();
1936     if ( idRoot.IsOk() )
1937     {
1938         FillArray((wxGenericTreeItem*) idRoot.m_pItem, array);
1939     }
1940     //else: the tree is empty, so no selections
1941
1942     return array.Count();
1943 }
1944
1945 void wxGenericTreeCtrl::EnsureVisible(const wxTreeItemId& item)
1946 {
1947     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
1948
1949     if (!item.IsOk()) return;
1950
1951     wxGenericTreeItem *gitem = (wxGenericTreeItem*) item.m_pItem;
1952
1953     // first expand all parent branches
1954     wxGenericTreeItem *parent = gitem->GetParent();
1955
1956     if ( HasFlag(wxTR_HIDE_ROOT) )
1957     {
1958         while ( parent && parent != m_anchor )
1959         {
1960             Expand(parent);
1961             parent = parent->GetParent();
1962         }
1963     }
1964     else
1965     {
1966         while ( parent )
1967         {
1968             Expand(parent);
1969             parent = parent->GetParent();
1970         }
1971     }
1972
1973     //if (parent) CalculatePositions();
1974
1975     ScrollTo(item);
1976 }
1977
1978 void wxGenericTreeCtrl::ScrollTo(const wxTreeItemId &item)
1979 {
1980     if (!item.IsOk()) return;
1981
1982     // We have to call this here because the label in
1983     // question might just have been added and no screen
1984     // update taken place.
1985     if (m_dirty)
1986 #if defined( __WXMSW__ ) || defined(__WXMAC__)
1987         Update();
1988 #else
1989         wxYieldIfNeeded();
1990 #endif
1991     wxGenericTreeItem *gitem = (wxGenericTreeItem*) item.m_pItem;
1992
1993     // now scroll to the item
1994     int item_y = gitem->GetY();
1995
1996     int start_x = 0;
1997     int start_y = 0;
1998     GetViewStart( &start_x, &start_y );
1999     start_y *= PIXELS_PER_UNIT;
2000
2001     int client_h = 0;
2002     int client_w = 0;
2003     GetClientSize( &client_w, &client_h );
2004
2005     if (item_y < start_y+3)
2006     {
2007         // going down
2008         int x = 0;
2009         int y = 0;
2010         m_anchor->GetSize( x, y, this );
2011         y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
2012         x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
2013         int x_pos = GetScrollPos( wxHORIZONTAL );
2014         // Item should appear at top
2015         SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, item_y/PIXELS_PER_UNIT );
2016     }
2017     else if (item_y+GetLineHeight(gitem) > start_y+client_h)
2018     {
2019         // going up
2020         int x = 0;
2021         int y = 0;
2022         m_anchor->GetSize( x, y, this );
2023         y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
2024         x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
2025         item_y += PIXELS_PER_UNIT+2;
2026         int x_pos = GetScrollPos( wxHORIZONTAL );
2027         // Item should appear at bottom
2028         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 );
2029     }
2030 }
2031
2032 // FIXME: tree sorting functions are not reentrant and not MT-safe!
2033 static wxGenericTreeCtrl *s_treeBeingSorted = NULL;
2034
2035 static int LINKAGEMODE tree_ctrl_compare_func(wxGenericTreeItem **item1,
2036                                   wxGenericTreeItem **item2)
2037 {
2038     wxCHECK_MSG( s_treeBeingSorted, 0, wxT("bug in wxGenericTreeCtrl::SortChildren()") );
2039
2040     return s_treeBeingSorted->OnCompareItems(*item1, *item2);
2041 }
2042
2043 void wxGenericTreeCtrl::SortChildren(const wxTreeItemId& itemId)
2044 {
2045     wxCHECK_RET( itemId.IsOk(), wxT("invalid tree item") );
2046
2047     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
2048
2049     wxCHECK_RET( !s_treeBeingSorted,
2050                  wxT("wxGenericTreeCtrl::SortChildren is not reentrant") );
2051
2052     wxArrayGenericTreeItems& children = item->GetChildren();
2053     if ( children.Count() > 1 )
2054     {
2055         m_dirty = true;
2056
2057         s_treeBeingSorted = this;
2058         children.Sort(tree_ctrl_compare_func);
2059         s_treeBeingSorted = NULL;
2060     }
2061     //else: don't make the tree dirty as nothing changed
2062 }
2063
2064 void wxGenericTreeCtrl::CalculateLineHeight()
2065 {
2066     wxClientDC dc(this);
2067     m_lineHeight = (int)(dc.GetCharHeight() + 4);
2068
2069     if ( m_imageListNormal )
2070     {
2071         // Calculate a m_lineHeight value from the normal Image sizes.
2072         // May be toggle off. Then wxGenericTreeCtrl will spread when
2073         // necessary (which might look ugly).
2074         int n = m_imageListNormal->GetImageCount();
2075         for (int i = 0; i < n ; i++)
2076         {
2077             int width = 0, height = 0;
2078             m_imageListNormal->GetSize(i, width, height);
2079             if (height > m_lineHeight) m_lineHeight = height;
2080         }
2081     }
2082
2083     if (m_imageListButtons)
2084     {
2085         // Calculate a m_lineHeight value from the Button image sizes.
2086         // May be toggle off. Then wxGenericTreeCtrl will spread when
2087         // necessary (which might look ugly).
2088         int n = m_imageListButtons->GetImageCount();
2089         for (int i = 0; i < n ; i++)
2090         {
2091             int width = 0, height = 0;
2092             m_imageListButtons->GetSize(i, width, height);
2093             if (height > m_lineHeight) m_lineHeight = height;
2094         }
2095     }
2096
2097     if (m_lineHeight < 30)
2098         m_lineHeight += 2;                 // at least 2 pixels
2099     else
2100         m_lineHeight += m_lineHeight/10;   // otherwise 10% extra spacing
2101 }
2102
2103 void wxGenericTreeCtrl::SetImageList(wxImageList *imageList)
2104 {
2105     if (m_ownsImageListNormal) delete m_imageListNormal;
2106     m_imageListNormal = imageList;
2107     m_ownsImageListNormal = false;
2108     m_dirty = true;
2109     // Don't do any drawing if we're setting the list to NULL,
2110     // since we may be in the process of deleting the tree control.
2111     if (imageList)
2112         CalculateLineHeight();
2113 }
2114
2115 void wxGenericTreeCtrl::SetStateImageList(wxImageList *imageList)
2116 {
2117     if (m_ownsImageListState) delete m_imageListState;
2118     m_imageListState = imageList;
2119     m_ownsImageListState = false;
2120 }
2121
2122 void wxGenericTreeCtrl::SetButtonsImageList(wxImageList *imageList)
2123 {
2124     if (m_ownsImageListButtons) delete m_imageListButtons;
2125     m_imageListButtons = imageList;
2126     m_ownsImageListButtons = false;
2127     m_dirty = true;
2128     CalculateLineHeight();
2129 }
2130
2131 void wxGenericTreeCtrl::AssignButtonsImageList(wxImageList *imageList)
2132 {
2133     SetButtonsImageList(imageList);
2134     m_ownsImageListButtons = true;
2135 }
2136
2137 // -----------------------------------------------------------------------------
2138 // helpers
2139 // -----------------------------------------------------------------------------
2140
2141 void wxGenericTreeCtrl::AdjustMyScrollbars()
2142 {
2143     if (m_anchor)
2144     {
2145         int x = 0, y = 0;
2146         m_anchor->GetSize( x, y, this );
2147         y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
2148         x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
2149         int x_pos = GetScrollPos( wxHORIZONTAL );
2150         int y_pos = GetScrollPos( wxVERTICAL );
2151         SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, y_pos );
2152     }
2153     else
2154     {
2155         SetScrollbars( 0, 0, 0, 0 );
2156     }
2157 }
2158
2159 int wxGenericTreeCtrl::GetLineHeight(wxGenericTreeItem *item) const
2160 {
2161     if (GetWindowStyleFlag() & wxTR_HAS_VARIABLE_ROW_HEIGHT)
2162         return item->GetHeight();
2163     else
2164         return m_lineHeight;
2165 }
2166
2167 void wxGenericTreeCtrl::PaintItem(wxGenericTreeItem *item, wxDC& dc)
2168 {
2169     // TODO implement "state" icon on items
2170
2171     wxTreeItemAttr *attr = item->GetAttributes();
2172     if ( attr && attr->HasFont() )
2173         dc.SetFont(attr->GetFont());
2174     else if (item->IsBold())
2175         dc.SetFont(m_boldFont);
2176
2177     long text_w = 0, text_h = 0;
2178     dc.GetTextExtent( item->GetText(), &text_w, &text_h );
2179
2180     int image_h = 0, image_w = 0;
2181     int image = item->GetCurrentImage();
2182     if ( image != NO_IMAGE )
2183     {
2184         if ( m_imageListNormal )
2185         {
2186             m_imageListNormal->GetSize( image, image_w, image_h );
2187             image_w += MARGIN_BETWEEN_IMAGE_AND_TEXT;
2188         }
2189         else
2190         {
2191             image = NO_IMAGE;
2192         }
2193     }
2194
2195     int total_h = GetLineHeight(item);
2196     bool drawItemBackground = false;
2197
2198     if ( item->IsSelected() )
2199     {
2200 // under mac selections are only a rectangle in case they don't have the focus
2201 #ifdef __WXMAC__
2202         if ( !m_hasFocus )
2203         {
2204             dc.SetBrush( *wxTRANSPARENT_BRUSH ) ;
2205             dc.SetPen( wxPen( wxSystemSettings::GetColour( wxSYS_COLOUR_HIGHLIGHT ) , 1 , wxSOLID ) ) ;
2206         }
2207         else
2208         {
2209             dc.SetBrush( *m_hilightBrush ) ;
2210         }
2211 #else
2212         dc.SetBrush(*(m_hasFocus ? m_hilightBrush : m_hilightUnfocusedBrush));
2213 #endif
2214         drawItemBackground = true;
2215     }
2216     else
2217     {
2218         wxColour colBg;
2219         if ( attr && attr->HasBackgroundColour() )
2220         {
2221             drawItemBackground = true;
2222             colBg = attr->GetBackgroundColour();
2223         }
2224         else
2225         {
2226             colBg = GetBackgroundColour();
2227         }
2228         dc.SetBrush(wxBrush(colBg, wxSOLID));
2229     }
2230
2231     int offset = HasFlag(wxTR_ROW_LINES) ? 1 : 0;
2232
2233     if ( HasFlag(wxTR_FULL_ROW_HIGHLIGHT) )
2234     {
2235         int x, y, w, h;
2236
2237         DoGetPosition(&x, &y);
2238         DoGetSize(&w, &h);
2239         dc.DrawRectangle(x, item->GetY()+offset, w, total_h-offset);
2240     }
2241     else
2242     {
2243         if ( item->IsSelected() && image != NO_IMAGE )
2244         {
2245             // If it's selected, and there's an image, then we should
2246             // take care to leave the area under the image painted in the
2247             // background colour.
2248             dc.DrawRectangle( item->GetX() + image_w - 2, item->GetY()+offset,
2249                               item->GetWidth() - image_w + 2, total_h-offset );
2250         }
2251         // On GTK+ 2, drawing a 'normal' background is wrong for themes that
2252         // don't allow backgrounds to be customized. Not drawing the background,
2253         // except for custom item backgrounds, works for both kinds of theme.
2254         else if (drawItemBackground)
2255         {
2256             dc.DrawRectangle( item->GetX()-2, item->GetY()+offset,
2257                               item->GetWidth()+2, total_h-offset );
2258         }
2259     }
2260
2261     if ( image != NO_IMAGE )
2262     {
2263         dc.SetClippingRegion( item->GetX(), item->GetY(), image_w-2, total_h );
2264         m_imageListNormal->Draw( image, dc,
2265                                  item->GetX(),
2266                                  item->GetY() +((total_h > image_h)?((total_h-image_h)/2):0),
2267                                  wxIMAGELIST_DRAW_TRANSPARENT );
2268         dc.DestroyClippingRegion();
2269     }
2270
2271     dc.SetBackgroundMode(wxTRANSPARENT);
2272     int extraH = (total_h > text_h) ? (total_h - text_h)/2 : 0;
2273     dc.DrawText( item->GetText(),
2274                  (wxCoord)(image_w + item->GetX()),
2275                  (wxCoord)(item->GetY() + extraH));
2276
2277     // restore normal font
2278     dc.SetFont( m_normalFont );
2279 }
2280
2281 // Now y stands for the top of the item, whereas it used to stand for middle !
2282 void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y )
2283 {
2284     int x = level*m_indent;
2285     if (!HasFlag(wxTR_HIDE_ROOT))
2286     {
2287         x += m_indent;
2288     }
2289     else if (level == 0)
2290     {
2291         // always expand hidden root
2292         int origY = y;
2293         wxArrayGenericTreeItems& children = item->GetChildren();
2294         int count = children.Count();
2295         if (count > 0)
2296         {
2297             int n = 0, oldY;
2298             do {
2299                 oldY = y;
2300                 PaintLevel(children[n], dc, 1, y);
2301             } while (++n < count);
2302
2303             if (!HasFlag(wxTR_NO_LINES) && HasFlag(wxTR_LINES_AT_ROOT) && count > 0)
2304             {
2305                 // draw line down to last child
2306                 origY += GetLineHeight(children[0])>>1;
2307                 oldY += GetLineHeight(children[n-1])>>1;
2308                 dc.DrawLine(3, origY, 3, oldY);
2309             }
2310         }
2311         return;
2312     }
2313
2314     item->SetX(x+m_spacing);
2315     item->SetY(y);
2316
2317     int h = GetLineHeight(item);
2318     int y_top = y;
2319     int y_mid = y_top + (h>>1);
2320     y += h;
2321
2322     int exposed_x = dc.LogicalToDeviceX(0);
2323     int exposed_y = dc.LogicalToDeviceY(y_top);
2324
2325     if (IsExposed(exposed_x, exposed_y, 10000, h))  // 10000 = very much
2326     {
2327         wxPen *pen =
2328 #ifndef __WXMAC__
2329             // don't draw rect outline if we already have the
2330             // background color under Mac
2331             (item->IsSelected() && m_hasFocus) ? wxBLACK_PEN :
2332 #endif // !__WXMAC__
2333             wxTRANSPARENT_PEN;
2334
2335         wxColour colText;
2336         if ( item->IsSelected() )
2337         {
2338             colText = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
2339         }
2340         else
2341         {
2342             wxTreeItemAttr *attr = item->GetAttributes();
2343             if (attr && attr->HasTextColour())
2344                 colText = attr->GetTextColour();
2345             else
2346                 colText = GetForegroundColour();
2347         }
2348
2349         // prepare to draw
2350         dc.SetTextForeground(colText);
2351         dc.SetPen(*pen);
2352
2353         // draw
2354         PaintItem(item, dc);
2355
2356         if (HasFlag(wxTR_ROW_LINES))
2357         {
2358             // if the background colour is white, choose a
2359             // contrasting color for the lines
2360             dc.SetPen(*((GetBackgroundColour() == *wxWHITE)
2361                          ? wxMEDIUM_GREY_PEN : wxWHITE_PEN));
2362             dc.DrawLine(0, y_top, 10000, y_top);
2363             dc.DrawLine(0, y, 10000, y);
2364         }
2365
2366         // restore DC objects
2367         dc.SetBrush(*wxWHITE_BRUSH);
2368         dc.SetPen(m_dottedPen);
2369         dc.SetTextForeground(*wxBLACK);
2370
2371         if ( !HasFlag(wxTR_NO_LINES) )
2372         {
2373             // draw the horizontal line here
2374             int x_start = x;
2375             if (x > (signed)m_indent)
2376                 x_start -= m_indent;
2377             else if (HasFlag(wxTR_LINES_AT_ROOT))
2378                 x_start = 3;
2379             dc.DrawLine(x_start, y_mid, x + m_spacing, y_mid);
2380         }
2381
2382         // should the item show a button?
2383         if ( item->HasPlus() && HasButtons() )
2384         {
2385             if ( m_imageListButtons )
2386             {
2387                 // draw the image button here
2388                 int image_h = 0,
2389                     image_w = 0;
2390                 int image = item->IsExpanded() ? wxTreeItemIcon_Expanded
2391                                                : wxTreeItemIcon_Normal;
2392                 if ( item->IsSelected() )
2393                     image += wxTreeItemIcon_Selected - wxTreeItemIcon_Normal;
2394
2395                 m_imageListButtons->GetSize(image, image_w, image_h);
2396                 int xx = x - image_w/2;
2397                 int yy = y_mid - image_h/2;
2398
2399                 wxDCClipper clip(dc, xx, yy, image_w, image_h);
2400                 m_imageListButtons->Draw(image, dc, xx, yy,
2401                                          wxIMAGELIST_DRAW_TRANSPARENT);
2402             }
2403             else // no custom buttons
2404             {
2405                 static const int wImage = 9;
2406                 static const int hImage = 9;
2407
2408                 int flag = 0;
2409                 if (item->IsExpanded())
2410                     flag |= wxCONTROL_EXPANDED;
2411                 if (item == m_underMouse)
2412                     flag |= wxCONTROL_CURRENT;
2413
2414                 wxRendererNative::Get().DrawTreeItemButton
2415                                         (
2416                                             this,
2417                                             dc,
2418                                             wxRect(x - wImage/2,
2419                                                    y_mid - hImage/2,
2420                                                    wImage, hImage),
2421                                             flag
2422                                         );
2423             }
2424         }
2425     }
2426
2427     if (item->IsExpanded())
2428     {
2429         wxArrayGenericTreeItems& children = item->GetChildren();
2430         int count = children.Count();
2431         if (count > 0)
2432         {
2433             int n = 0, oldY;
2434             ++level;
2435             do {
2436                 oldY = y;
2437                 PaintLevel(children[n], dc, level, y);
2438             } while (++n < count);
2439
2440             if (!HasFlag(wxTR_NO_LINES) && count > 0)
2441             {
2442                 // draw line down to last child
2443                 oldY += GetLineHeight(children[n-1])>>1;
2444                 if (HasButtons()) y_mid += 5;
2445
2446                 // Only draw the portion of the line that is visible, in case it is huge
2447                 wxCoord xOrigin=0, yOrigin=0, width, height;
2448                 dc.GetDeviceOrigin(&xOrigin, &yOrigin);
2449                 yOrigin = abs(yOrigin);
2450                 GetClientSize(&width, &height);
2451
2452                 // Move end points to the begining/end of the view?
2453                 if (y_mid < yOrigin)
2454                     y_mid = yOrigin;
2455                 if (oldY > yOrigin + height)
2456                     oldY = yOrigin + height;
2457
2458                 // after the adjustments if y_mid is larger than oldY then the line
2459                 // isn't visible at all so don't draw anything
2460                 if (y_mid < oldY)
2461                     dc.DrawLine(x, y_mid, x, oldY);
2462             }
2463         }
2464     }
2465 }
2466
2467 void wxGenericTreeCtrl::DrawDropEffect(wxGenericTreeItem *item)
2468 {
2469     if ( item )
2470     {
2471         if ( item->HasPlus() )
2472         {
2473             // it's a folder, indicate it by a border
2474             DrawBorder(item);
2475         }
2476         else
2477         {
2478             // draw a line under the drop target because the item will be
2479             // dropped there
2480             DrawLine(item, !m_dropEffectAboveItem );
2481         }
2482
2483         SetCursor(wxCURSOR_BULLSEYE);
2484     }
2485     else
2486     {
2487         // can't drop here
2488         SetCursor(wxCURSOR_NO_ENTRY);
2489     }
2490 }
2491
2492 void wxGenericTreeCtrl::DrawBorder(const wxTreeItemId &item)
2493 {
2494     wxCHECK_RET( item.IsOk(), _T("invalid item in wxGenericTreeCtrl::DrawLine") );
2495
2496     wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
2497
2498     wxClientDC dc(this);
2499     PrepareDC( dc );
2500     dc.SetLogicalFunction(wxINVERT);
2501     dc.SetBrush(*wxTRANSPARENT_BRUSH);
2502
2503     int w = i->GetWidth() + 2;
2504     int h = GetLineHeight(i) + 2;
2505
2506     dc.DrawRectangle( i->GetX() - 1, i->GetY() - 1, w, h);
2507 }
2508
2509 void wxGenericTreeCtrl::DrawLine(const wxTreeItemId &item, bool below)
2510 {
2511     wxCHECK_RET( item.IsOk(), _T("invalid item in wxGenericTreeCtrl::DrawLine") );
2512
2513     wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
2514
2515     wxClientDC dc(this);
2516     PrepareDC( dc );
2517     dc.SetLogicalFunction(wxINVERT);
2518
2519     int x = i->GetX(),
2520         y = i->GetY();
2521     if ( below )
2522     {
2523         y += GetLineHeight(i) - 1;
2524     }
2525
2526     dc.DrawLine( x, y, x + i->GetWidth(), y);
2527 }
2528
2529 // -----------------------------------------------------------------------------
2530 // wxWidgets callbacks
2531 // -----------------------------------------------------------------------------
2532
2533 void wxGenericTreeCtrl::OnPaint( wxPaintEvent &WXUNUSED(event) )
2534 {
2535     wxPaintDC dc(this);
2536     PrepareDC( dc );
2537
2538     if ( !m_anchor)
2539         return;
2540
2541     dc.SetFont( m_normalFont );
2542     dc.SetPen( m_dottedPen );
2543
2544     // this is now done dynamically
2545     //if(GetImageList() == NULL)
2546     // m_lineHeight = (int)(dc.GetCharHeight() + 4);
2547
2548     int y = 2;
2549     PaintLevel( m_anchor, dc, 0, y );
2550 }
2551
2552 void wxGenericTreeCtrl::OnSetFocus( wxFocusEvent &event )
2553 {
2554     m_hasFocus = true;
2555
2556     RefreshSelected();
2557
2558     event.Skip();
2559 }
2560
2561 void wxGenericTreeCtrl::OnKillFocus( wxFocusEvent &event )
2562 {
2563     m_hasFocus = false;
2564
2565     RefreshSelected();
2566
2567     event.Skip();
2568 }
2569
2570 void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
2571 {
2572     wxTreeEvent te( wxEVT_COMMAND_TREE_KEY_DOWN, GetId() );
2573     te.m_evtKey = event;
2574     te.SetEventObject( this );
2575     if ( GetEventHandler()->ProcessEvent( te ) )
2576     {
2577         // intercepted by the user code
2578         return;
2579     }
2580
2581     if ( (m_current == 0) || (m_key_current == 0) )
2582     {
2583         event.Skip();
2584         return;
2585     }
2586
2587     // how should the selection work for this event?
2588     bool is_multiple, extended_select, unselect_others;
2589     EventFlagsToSelType(GetWindowStyleFlag(),
2590                         event.ShiftDown(),
2591                         event.CmdDown(),
2592                         is_multiple, extended_select, unselect_others);
2593
2594     // + : Expand
2595     // - : Collaspe
2596     // * : Expand all/Collapse all
2597     // ' ' | return : activate
2598     // up    : go up (not last children!)
2599     // down  : go down
2600     // left  : go to parent
2601     // right : open if parent and go next
2602     // home  : go to root
2603     // end   : go to last item without opening parents
2604     // alnum : start or continue searching for the item with this prefix
2605     int keyCode = event.GetKeyCode();
2606     switch ( keyCode )
2607     {
2608         case '+':
2609         case WXK_ADD:
2610             if (m_current->HasPlus() && !IsExpanded(m_current))
2611             {
2612                 Expand(m_current);
2613             }
2614             break;
2615
2616         case '*':
2617         case WXK_MULTIPLY:
2618             if ( !IsExpanded(m_current) )
2619             {
2620                 // expand all
2621                 ExpandAll(m_current);
2622                 break;
2623             }
2624             //else: fall through to Collapse() it
2625
2626         case '-':
2627         case WXK_SUBTRACT:
2628             if (IsExpanded(m_current))
2629             {
2630                 Collapse(m_current);
2631             }
2632             break;
2633
2634         case WXK_MENU:
2635             {
2636                 // Use the item's bounding rectangle to determine position for the event
2637                 wxRect ItemRect;
2638                 GetBoundingRect(m_current, ItemRect, true);
2639
2640                 wxTreeEvent eventMenu( wxEVT_COMMAND_TREE_ITEM_MENU, GetId() );
2641                 eventMenu.m_item = m_current;
2642                 // Use the left edge, vertical middle
2643                 eventMenu.m_pointDrag = wxPoint(ItemRect.GetX(),
2644                                                 ItemRect.GetY() + ItemRect.GetHeight() / 2);
2645                 eventMenu.SetEventObject( this );
2646                 GetEventHandler()->ProcessEvent( eventMenu );
2647                 break;
2648             }
2649         case ' ':
2650         case WXK_RETURN:
2651             if ( !event.HasModifiers() )
2652             {
2653                 wxTreeEvent eventAct( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
2654                 eventAct.m_item = m_current;
2655                 eventAct.SetEventObject( this );
2656                 GetEventHandler()->ProcessEvent( eventAct );
2657             }
2658
2659             // in any case, also generate the normal key event for this key,
2660             // even if we generated the ACTIVATED event above: this is what
2661             // wxMSW does and it makes sense because you might not want to
2662             // process ACTIVATED event at all and handle Space and Return
2663             // directly (and differently) which would be impossible otherwise
2664             event.Skip();
2665             break;
2666
2667             // up goes to the previous sibling or to the last
2668             // of its children if it's expanded
2669         case WXK_UP:
2670             {
2671                 wxTreeItemId prev = GetPrevSibling( m_key_current );
2672                 if (!prev)
2673                 {
2674                     prev = GetItemParent( m_key_current );
2675                     if ((prev == GetRootItem()) && HasFlag(wxTR_HIDE_ROOT))
2676                     {
2677                         break;  // don't go to root if it is hidden
2678                     }
2679                     if (prev)
2680                     {
2681                         wxTreeItemIdValue cookie;
2682                         wxTreeItemId current = m_key_current;
2683                         // TODO: Huh?  If we get here, we'd better be the first child of our parent.  How else could it be?
2684                         if (current == GetFirstChild( prev, cookie ))
2685                         {
2686                             // otherwise we return to where we came from
2687                             DoSelectItem( prev, unselect_others, extended_select );
2688                             m_key_current= (wxGenericTreeItem*) prev.m_pItem;
2689                             break;
2690                         }
2691                     }
2692                 }
2693                 if (prev)
2694                 {
2695                     while ( IsExpanded(prev) && HasChildren(prev) )
2696                     {
2697                         wxTreeItemId child = GetLastChild(prev);
2698                         if ( child )
2699                         {
2700                             prev = child;
2701                         }
2702                     }
2703
2704                     DoSelectItem( prev, unselect_others, extended_select );
2705                     m_key_current=(wxGenericTreeItem*) prev.m_pItem;
2706                 }
2707             }
2708             break;
2709
2710             // left arrow goes to the parent
2711         case WXK_LEFT:
2712             {
2713                 wxTreeItemId prev = GetItemParent( m_current );
2714                 if ((prev == GetRootItem()) && HasFlag(wxTR_HIDE_ROOT))
2715                 {
2716                     // don't go to root if it is hidden
2717                     prev = GetPrevSibling( m_current );
2718                 }
2719                 if (prev)
2720                 {
2721                     DoSelectItem( prev, unselect_others, extended_select );
2722                 }
2723             }
2724             break;
2725
2726         case WXK_RIGHT:
2727             // this works the same as the down arrow except that we
2728             // also expand the item if it wasn't expanded yet
2729             Expand(m_current);
2730             // fall through
2731
2732         case WXK_DOWN:
2733             {
2734                 if (IsExpanded(m_key_current) && HasChildren(m_key_current))
2735                 {
2736                     wxTreeItemIdValue cookie;
2737                     wxTreeItemId child = GetFirstChild( m_key_current, cookie );
2738                     DoSelectItem( child, unselect_others, extended_select );
2739                     m_key_current=(wxGenericTreeItem*) child.m_pItem;
2740                 }
2741                 else
2742                 {
2743                     wxTreeItemId next = GetNextSibling( m_key_current );
2744                     if (!next)
2745                     {
2746                         wxTreeItemId current = m_key_current;
2747                         while (current.IsOk() && !next)
2748                         {
2749                             current = GetItemParent( current );
2750                             if (current) next = GetNextSibling( current );
2751                         }
2752                     }
2753                     if (next)
2754                     {
2755                         DoSelectItem( next, unselect_others, extended_select );
2756                         m_key_current=(wxGenericTreeItem*) next.m_pItem;
2757                     }
2758                 }
2759             }
2760             break;
2761
2762             // <End> selects the last visible tree item
2763         case WXK_END:
2764             {
2765                 wxTreeItemId last = GetRootItem();
2766
2767                 while ( last.IsOk() && IsExpanded(last) )
2768                 {
2769                     wxTreeItemId lastChild = GetLastChild(last);
2770
2771                     // it may happen if the item was expanded but then all of
2772                     // its children have been deleted - so IsExpanded() returned
2773                     // true, but GetLastChild() returned invalid item
2774                     if ( !lastChild )
2775                         break;
2776
2777                     last = lastChild;
2778                 }
2779
2780                 if ( last.IsOk() )
2781                 {
2782                     DoSelectItem( last, unselect_others, extended_select );
2783                 }
2784             }
2785             break;
2786
2787             // <Home> selects the root item
2788         case WXK_HOME:
2789             {
2790                 wxTreeItemId prev = GetRootItem();
2791                 if (!prev)
2792                     break;
2793
2794                 if ( HasFlag(wxTR_HIDE_ROOT) )
2795                 {
2796                     wxTreeItemIdValue cookie;
2797                     prev = GetFirstChild(prev, cookie);
2798                     if (!prev)
2799                         break;
2800                 }
2801
2802                 DoSelectItem( prev, unselect_others, extended_select );
2803             }
2804             break;
2805
2806         default:
2807             // do not use wxIsalnum() here
2808             if ( !event.HasModifiers() &&
2809                  ((keyCode >= '0' && keyCode <= '9') ||
2810                   (keyCode >= 'a' && keyCode <= 'z') ||
2811                   (keyCode >= 'A' && keyCode <= 'Z' )))
2812             {
2813                 // find the next item starting with the given prefix
2814                 wxChar ch = (wxChar)keyCode;
2815
2816                 wxTreeItemId id = FindItem(m_current, m_findPrefix + ch);
2817                 if ( !id.IsOk() )
2818                 {
2819                     // no such item
2820                     break;
2821                 }
2822
2823                 SelectItem(id);
2824
2825                 m_findPrefix += ch;
2826
2827                 // also start the timer to reset the current prefix if the user
2828                 // doesn't press any more alnum keys soon -- we wouldn't want
2829                 // to use this prefix for a new item search
2830                 if ( !m_findTimer )
2831                 {
2832                     m_findTimer = new wxTreeFindTimer(this);
2833                 }
2834
2835                 m_findTimer->Start(wxTreeFindTimer::DELAY, wxTIMER_ONE_SHOT);
2836             }
2837             else
2838             {
2839                 event.Skip();
2840             }
2841     }
2842 }
2843
2844 wxTreeItemId wxGenericTreeCtrl::DoTreeHitTest(const wxPoint& point, int& flags)
2845 {
2846     // JACS: removed wxYieldIfNeeded() because it can cause the window
2847     // to be deleted from under us if a close window event is pending
2848
2849     int w, h;
2850     GetSize(&w, &h);
2851     flags=0;
2852     if (point.x<0) flags |= wxTREE_HITTEST_TOLEFT;
2853     if (point.x>w) flags |= wxTREE_HITTEST_TORIGHT;
2854     if (point.y<0) flags |= wxTREE_HITTEST_ABOVE;
2855     if (point.y>h) flags |= wxTREE_HITTEST_BELOW;
2856     if (flags) return wxTreeItemId();
2857
2858     if (m_anchor == NULL)
2859     {
2860         flags = wxTREE_HITTEST_NOWHERE;
2861         return wxTreeItemId();
2862     }
2863
2864     wxGenericTreeItem *hit =  m_anchor->HitTest(CalcUnscrolledPosition(point),
2865                                                 this, flags, 0);
2866     if (hit == NULL)
2867     {
2868         flags = wxTREE_HITTEST_NOWHERE;
2869         return wxTreeItemId();
2870     }
2871     return hit;
2872 }
2873
2874 // get the bounding rectangle of the item (or of its label only)
2875 bool wxGenericTreeCtrl::GetBoundingRect(const wxTreeItemId& item,
2876                                         wxRect& rect,
2877                                         bool textOnly) const
2878 {
2879     wxCHECK_MSG( item.IsOk(), false, _T("invalid item in wxGenericTreeCtrl::GetBoundingRect") );
2880
2881     wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
2882
2883     int startX, startY;
2884     GetViewStart(& startX, & startY);
2885
2886     if ( textOnly )
2887     {
2888         rect.x = i->GetX() - startX*PIXELS_PER_UNIT;
2889         rect.width = i->GetWidth();
2890
2891         if ( m_imageListNormal )
2892         {
2893             int image_w, image_h;
2894             m_imageListNormal->GetSize( 0, image_w, image_h );
2895             rect.width += image_w + MARGIN_BETWEEN_IMAGE_AND_TEXT;
2896         }
2897     }
2898     else // the entire line
2899     {
2900         rect.x = 0;
2901         rect.width = GetClientSize().x;
2902     }
2903
2904     rect.y = i->GetY() - startY*PIXELS_PER_UNIT;
2905     rect.height = GetLineHeight(i);
2906
2907     return true;
2908 }
2909
2910 wxTextCtrl *wxGenericTreeCtrl::EditLabel(const wxTreeItemId& item,
2911                                   wxClassInfo * WXUNUSED(textCtrlClass))
2912 {
2913     wxCHECK_MSG( item.IsOk(), NULL, _T("can't edit an invalid item") );
2914
2915     wxGenericTreeItem *itemEdit = (wxGenericTreeItem *)item.m_pItem;
2916
2917     wxTreeEvent te( wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, GetId() );
2918     te.m_item = itemEdit;
2919     te.SetEventObject( this );
2920     if ( GetEventHandler()->ProcessEvent( te ) && !te.IsAllowed() )
2921     {
2922         // vetoed by user
2923         return NULL;
2924     }
2925
2926     // We have to call this here because the label in
2927     // question might just have been added and no screen
2928     // update taken place.
2929     if ( m_dirty )
2930 #if defined( __WXMSW__ ) || defined(__WXMAC__)
2931         Update();
2932 #else
2933         wxYieldIfNeeded();
2934 #endif
2935
2936     // TODO: use textCtrlClass here to create the control of correct class
2937     m_textCtrl = new wxTreeTextCtrl(this, itemEdit);
2938
2939     m_textCtrl->SetFocus();
2940
2941     return m_textCtrl;
2942 }
2943
2944 // returns a pointer to the text edit control if the item is being
2945 // edited, NULL otherwise (it's assumed that no more than one item may
2946 // be edited simultaneously)
2947 wxTextCtrl* wxGenericTreeCtrl::GetEditControl() const
2948 {
2949     return m_textCtrl;
2950 }
2951
2952 void wxGenericTreeCtrl::EndEditLabel(const wxTreeItemId& WXUNUSED(item),
2953                                      bool discardChanges)
2954 {
2955     wxCHECK_RET( m_textCtrl, _T("not editing label") );
2956
2957     m_textCtrl->EndEdit(discardChanges);
2958 }
2959
2960 bool wxGenericTreeCtrl::OnRenameAccept(wxGenericTreeItem *item,
2961                                        const wxString& value)
2962 {
2963     wxTreeEvent le( wxEVT_COMMAND_TREE_END_LABEL_EDIT, GetId() );
2964     le.m_item = item;
2965     le.SetEventObject( this );
2966     le.m_label = value;
2967     le.m_editCancelled = false;
2968
2969     return !GetEventHandler()->ProcessEvent( le ) || le.IsAllowed();
2970 }
2971
2972 void wxGenericTreeCtrl::OnRenameCancelled(wxGenericTreeItem *item)
2973 {
2974     // let owner know that the edit was cancelled
2975     wxTreeEvent le( wxEVT_COMMAND_TREE_END_LABEL_EDIT, GetId() );
2976     le.m_item = item;
2977     le.SetEventObject( this );
2978     le.m_label = wxEmptyString;
2979     le.m_editCancelled = true;
2980
2981     GetEventHandler()->ProcessEvent( le );
2982 }
2983
2984 void wxGenericTreeCtrl::OnRenameTimer()
2985 {
2986     EditLabel( m_current );
2987 }
2988
2989 void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
2990 {
2991     if ( !m_anchor ) return;
2992
2993     wxPoint pt = CalcUnscrolledPosition(event.GetPosition());
2994
2995     // Is the mouse over a tree item button?
2996     int flags = 0;
2997     wxGenericTreeItem *thisItem = m_anchor->HitTest(pt, this, flags, 0);
2998     wxGenericTreeItem *underMouse = thisItem;
2999 #if wxUSE_TOOLTIPS
3000     bool underMouseChanged = (underMouse != m_underMouse) ;
3001 #endif // wxUSE_TOOLTIPS
3002
3003     if ((underMouse) &&
3004         (flags & wxTREE_HITTEST_ONITEMBUTTON) &&
3005         (!event.LeftIsDown()) &&
3006         (!m_isDragging) &&
3007         (!m_renameTimer || !m_renameTimer->IsRunning()))
3008     {
3009     }
3010     else
3011     {
3012         underMouse = NULL;
3013     }
3014
3015     if (underMouse != m_underMouse)
3016     {
3017          if (m_underMouse)
3018          {
3019             // unhighlight old item
3020             wxGenericTreeItem *tmp = m_underMouse;
3021             m_underMouse = NULL;
3022             RefreshLine( tmp );
3023          }
3024
3025          m_underMouse = underMouse;
3026          if (m_underMouse)
3027             RefreshLine( m_underMouse );
3028     }
3029
3030 #if wxUSE_TOOLTIPS
3031     // Determines what item we are hovering over and need a tooltip for
3032     wxTreeItemId hoverItem = thisItem;
3033
3034     // We do not want a tooltip if we are dragging, or if the rename timer is running
3035     if (underMouseChanged && hoverItem.IsOk() && !m_isDragging && (!m_renameTimer || !m_renameTimer->IsRunning()))
3036     {
3037         // Ask the tree control what tooltip (if any) should be shown
3038         wxTreeEvent hevent(wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP, GetId());
3039         hevent.m_item = hoverItem;
3040         hevent.SetEventObject(this);
3041
3042         if ( GetEventHandler()->ProcessEvent(hevent) && hevent.IsAllowed() )
3043         {
3044             SetToolTip(hevent.m_label);
3045         }
3046     }
3047 #endif
3048
3049     // we process left mouse up event (enables in-place edit), right down
3050     // (pass to the user code), left dbl click (activate item) and
3051     // dragging/moving events for items drag-and-drop
3052     if ( !(event.LeftDown() ||
3053            event.LeftUp() ||
3054            event.RightDown() ||
3055            event.LeftDClick() ||
3056            event.Dragging() ||
3057            ((event.Moving() || event.RightUp()) && m_isDragging)) )
3058     {
3059         event.Skip();
3060
3061         return;
3062     }
3063
3064
3065     flags = 0;
3066     wxGenericTreeItem *item = m_anchor->HitTest(pt, this, flags, 0);
3067
3068     if ( event.Dragging() && !m_isDragging )
3069     {
3070         if (m_dragCount == 0)
3071             m_dragStart = pt;
3072
3073         m_dragCount++;
3074
3075         if (m_dragCount != 3)
3076         {
3077             // wait until user drags a bit further...
3078             return;
3079         }
3080
3081         wxEventType command = event.RightIsDown()
3082                               ? wxEVT_COMMAND_TREE_BEGIN_RDRAG
3083                               : wxEVT_COMMAND_TREE_BEGIN_DRAG;
3084
3085         wxTreeEvent nevent( command, GetId() );
3086         nevent.m_item = m_current;
3087         nevent.SetEventObject(this);
3088         nevent.SetPoint(CalcScrolledPosition(pt));
3089
3090         // by default the dragging is not supported, the user code must
3091         // explicitly allow the event for it to take place
3092         nevent.Veto();
3093
3094         if ( GetEventHandler()->ProcessEvent(nevent) && nevent.IsAllowed() )
3095         {
3096             // we're going to drag this item
3097             m_isDragging = true;
3098
3099             // remember the old cursor because we will change it while
3100             // dragging
3101             m_oldCursor = m_cursor;
3102
3103             // in a single selection control, hide the selection temporarily
3104             if ( !(GetWindowStyleFlag() & wxTR_MULTIPLE) )
3105             {
3106                 m_oldSelection = (wxGenericTreeItem*) GetSelection().m_pItem;
3107
3108                 if ( m_oldSelection )
3109                 {
3110                     m_oldSelection->SetHilight(false);
3111                     RefreshLine(m_oldSelection);
3112                 }
3113             }
3114
3115             CaptureMouse();
3116         }
3117     }
3118     else if ( event.Dragging() )
3119     {
3120         if ( item != m_dropTarget )
3121         {
3122             // unhighlight the previous drop target
3123             DrawDropEffect(m_dropTarget);
3124
3125             m_dropTarget = item;
3126
3127             // highlight the current drop target if any
3128             DrawDropEffect(m_dropTarget);
3129
3130 #if defined(__WXMSW__) || defined(__WXMAC__) || defined(__WXGTK20__)
3131             Update();
3132 #else
3133             wxYieldIfNeeded();
3134 #endif
3135         }
3136     }
3137     else if ( (event.LeftUp() || event.RightUp()) && m_isDragging )
3138     {
3139         // erase the highlighting
3140         DrawDropEffect(m_dropTarget);
3141
3142         if ( m_oldSelection )
3143         {
3144             m_oldSelection->SetHilight(true);
3145             RefreshLine(m_oldSelection);
3146             m_oldSelection = (wxGenericTreeItem *)NULL;
3147         }
3148
3149         // generate the drag end event
3150         wxTreeEvent eventEndDrag(wxEVT_COMMAND_TREE_END_DRAG, GetId());
3151
3152         eventEndDrag.m_item = item;
3153         eventEndDrag.m_pointDrag = CalcScrolledPosition(pt);
3154         eventEndDrag.SetEventObject(this);
3155
3156         (void)GetEventHandler()->ProcessEvent(eventEndDrag);
3157
3158         m_isDragging = false;
3159         m_dropTarget = (wxGenericTreeItem *)NULL;
3160
3161         ReleaseMouse();
3162
3163         SetCursor(m_oldCursor);
3164
3165 #if defined( __WXMSW__ ) || defined(__WXMAC__)
3166         Update();
3167 #else
3168         wxYieldIfNeeded();
3169 #endif
3170     }
3171     else
3172     {
3173         // If we got to this point, we are not dragging or moving the mouse.
3174         // Because the code in carbon/toplevel.cpp will only set focus to the tree
3175         // if we skip for EVT_LEFT_DOWN, we MUST skip this event here for focus to work.
3176         // We skip even if we didn't hit an item because we still should
3177         // restore focus to the tree control even if we didn't exactly hit an item.
3178         if ( event.LeftDown() )
3179         {
3180             event.Skip();
3181         }
3182
3183         // here we process only the messages which happen on tree items
3184
3185         m_dragCount = 0;
3186
3187         if (item == NULL) return;  /* we hit the blank area */
3188
3189         if ( event.RightDown() )
3190         {
3191             // If the item is already selected, do not update the selection.
3192             // Multi-selections should not be cleared if a selected item is clicked.
3193             if (!IsSelected(item))
3194             {
3195                 DoSelectItem(item, true, false);
3196             }
3197
3198             wxTreeEvent nevent(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK, GetId());
3199             nevent.m_item = item;
3200             nevent.m_pointDrag = CalcScrolledPosition(pt);
3201             nevent.SetEventObject(this);
3202             event.Skip(!GetEventHandler()->ProcessEvent(nevent));
3203
3204             // Consistent with MSW (for now), send the ITEM_MENU *after*
3205             // the RIGHT_CLICK event. TODO: This behavior may change.
3206             wxTreeEvent nevent2(wxEVT_COMMAND_TREE_ITEM_MENU, GetId());
3207             nevent2.m_item = item;
3208             nevent2.m_pointDrag = CalcScrolledPosition(pt);
3209             nevent2.SetEventObject(this);
3210             GetEventHandler()->ProcessEvent(nevent2);
3211         }
3212         else if ( event.LeftUp() )
3213         {
3214             // this facilitates multiple-item drag-and-drop
3215
3216             if ( /* item && */ HasFlag(wxTR_MULTIPLE))
3217             {
3218                 wxArrayTreeItemIds selections;
3219                 size_t count = GetSelections(selections);
3220
3221                 if (count > 1 &&
3222                     !event.CmdDown() &&
3223                     !event.ShiftDown())
3224                 {
3225                     DoSelectItem(item, true, false);
3226                 }
3227             }
3228
3229             if ( m_lastOnSame )
3230             {
3231                 if ( (item == m_current) &&
3232                      (flags & wxTREE_HITTEST_ONITEMLABEL) &&
3233                      HasFlag(wxTR_EDIT_LABELS) )
3234                 {
3235                     if ( m_renameTimer )
3236                     {
3237                         if ( m_renameTimer->IsRunning() )
3238                             m_renameTimer->Stop();
3239                     }
3240                     else
3241                     {
3242                         m_renameTimer = new wxTreeRenameTimer( this );
3243                     }
3244
3245                     m_renameTimer->Start( wxTreeRenameTimer::DELAY, true );
3246                 }
3247
3248                 m_lastOnSame = false;
3249             }
3250         }
3251         else // !RightDown() && !LeftUp() ==> LeftDown() || LeftDClick()
3252         {
3253             if ( event.LeftDown() )
3254             {
3255                 m_lastOnSame = item == m_current;
3256             }
3257
3258             if ( flags & wxTREE_HITTEST_ONITEMBUTTON )
3259             {
3260                 // only toggle the item for a single click, double click on
3261                 // the button doesn't do anything (it toggles the item twice)
3262                 if ( event.LeftDown() )
3263                 {
3264                     Toggle( item );
3265                 }
3266
3267                 // don't select the item if the button was clicked
3268                 return;
3269             }
3270
3271
3272             // clear the previously selected items, if the
3273             // user clicked outside of the present selection.
3274             // otherwise, perform the deselection on mouse-up.
3275             // this allows multiple drag and drop to work.
3276             // but if Cmd is down, toggle selection of the clicked item
3277             if (!IsSelected(item) || event.CmdDown())
3278             {
3279                 // how should the selection work for this event?
3280                 bool is_multiple, extended_select, unselect_others;
3281                 EventFlagsToSelType(GetWindowStyleFlag(),
3282                                     event.ShiftDown(),
3283                                     event.CmdDown(),
3284                                     is_multiple, extended_select, unselect_others);
3285
3286                 DoSelectItem(item, unselect_others, extended_select);
3287             }
3288
3289
3290             // For some reason, Windows isn't recognizing a left double-click,
3291             // so we need to simulate it here.  Allow 200 milliseconds for now.
3292             if ( event.LeftDClick() )
3293             {
3294                 // double clicking should not start editing the item label
3295                 if ( m_renameTimer )
3296                     m_renameTimer->Stop();
3297
3298                 m_lastOnSame = false;
3299
3300                 // send activate event first
3301                 wxTreeEvent nevent( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
3302                 nevent.m_item = item;
3303                 nevent.m_pointDrag = CalcScrolledPosition(pt);
3304                 nevent.SetEventObject( this );
3305                 if ( !GetEventHandler()->ProcessEvent( nevent ) )
3306                 {
3307                     // if the user code didn't process the activate event,
3308                     // handle it ourselves by toggling the item when it is
3309                     // double clicked
3310                     if ( item->HasPlus() )
3311                     {
3312                         Toggle(item);
3313                     }
3314                 }
3315             }
3316         }
3317     }
3318 }
3319
3320 void wxGenericTreeCtrl::OnInternalIdle()
3321 {
3322     wxWindow::OnInternalIdle();
3323
3324     // Check if we need to select the root item
3325     // because nothing else has been selected.
3326     // Delaying it means that we can invoke event handlers
3327     // as required, when a first item is selected.
3328     if (!HasFlag(wxTR_MULTIPLE) && !GetSelection().IsOk())
3329     {
3330         if (m_select_me)
3331             SelectItem(m_select_me);
3332         else if (GetRootItem().IsOk())
3333             SelectItem(GetRootItem());
3334     }
3335
3336     /* after all changes have been done to the tree control,
3337      * we actually redraw the tree when everything is over */
3338
3339     if (!m_dirty) return;
3340     if (m_freezeCount) return;
3341
3342     m_dirty = false;
3343
3344     CalculatePositions();
3345     Refresh();
3346     AdjustMyScrollbars();
3347 }
3348
3349 void wxGenericTreeCtrl::CalculateSize( wxGenericTreeItem *item, wxDC &dc )
3350 {
3351     wxCoord text_w = 0;
3352     wxCoord text_h = 0;
3353
3354     wxTreeItemAttr *attr = item->GetAttributes();
3355     if ( attr && attr->HasFont() )
3356         dc.SetFont(attr->GetFont());
3357     else if ( item->IsBold() )
3358         dc.SetFont(m_boldFont);
3359     else
3360         dc.SetFont(m_normalFont);
3361
3362     dc.GetTextExtent( item->GetText(), &text_w, &text_h );
3363     text_h+=2;
3364
3365     // restore normal font
3366     dc.SetFont( m_normalFont );
3367
3368     int image_h = 0;
3369     int image_w = 0;
3370     int image = item->GetCurrentImage();
3371     if ( image != NO_IMAGE )
3372     {
3373         if ( m_imageListNormal )
3374         {
3375             m_imageListNormal->GetSize( image, image_w, image_h );
3376             image_w += MARGIN_BETWEEN_IMAGE_AND_TEXT;
3377         }
3378     }
3379
3380     int total_h = (image_h > text_h) ? image_h : text_h;
3381
3382     if (total_h < 30)
3383         total_h += 2;            // at least 2 pixels
3384     else
3385         total_h += total_h/10;   // otherwise 10% extra spacing
3386
3387     item->SetHeight(total_h);
3388     if (total_h>m_lineHeight)
3389         m_lineHeight=total_h;
3390
3391     item->SetWidth(image_w+text_w+2);
3392 }
3393
3394 // -----------------------------------------------------------------------------
3395 // for developper : y is now the top of the level
3396 // not the middle of it !
3397 void wxGenericTreeCtrl::CalculateLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y )
3398 {
3399     int x = level*m_indent;
3400     if (!HasFlag(wxTR_HIDE_ROOT))
3401     {
3402         x += m_indent;
3403     }
3404     else if (level == 0)
3405     {
3406         // a hidden root is not evaluated, but its
3407         // children are always calculated
3408         goto Recurse;
3409     }
3410
3411     CalculateSize( item, dc );
3412
3413     // set its position
3414     item->SetX( x+m_spacing );
3415     item->SetY( y );
3416     y += GetLineHeight(item);
3417
3418     if ( !item->IsExpanded() )
3419     {
3420         // we don't need to calculate collapsed branches
3421         return;
3422     }
3423
3424   Recurse:
3425     wxArrayGenericTreeItems& children = item->GetChildren();
3426     size_t n, count = children.Count();
3427     ++level;
3428     for (n = 0; n < count; ++n )
3429         CalculateLevel( children[n], dc, level, y );  // recurse
3430 }
3431
3432 void wxGenericTreeCtrl::CalculatePositions()
3433 {
3434     if ( !m_anchor ) return;
3435
3436     wxClientDC dc(this);
3437     PrepareDC( dc );
3438
3439     dc.SetFont( m_normalFont );
3440
3441     dc.SetPen( m_dottedPen );
3442     //if(GetImageList() == NULL)
3443     // m_lineHeight = (int)(dc.GetCharHeight() + 4);
3444
3445     int y = 2;
3446     CalculateLevel( m_anchor, dc, 0, y ); // start recursion
3447 }
3448
3449 void wxGenericTreeCtrl::RefreshSubtree(wxGenericTreeItem *item)
3450 {
3451     if (m_dirty) return;
3452     if (m_freezeCount) return;
3453
3454     wxSize client = GetClientSize();
3455
3456     wxRect rect;
3457     CalcScrolledPosition(0, item->GetY(), NULL, &rect.y);
3458     rect.width = client.x;
3459     rect.height = client.y;
3460
3461     Refresh(true, &rect);
3462
3463     AdjustMyScrollbars();
3464 }
3465
3466 void wxGenericTreeCtrl::RefreshLine( wxGenericTreeItem *item )
3467 {
3468     if (m_dirty) return;
3469     if (m_freezeCount) return;
3470
3471     wxRect rect;
3472     CalcScrolledPosition(0, item->GetY(), NULL, &rect.y);
3473     rect.width = GetClientSize().x;
3474     rect.height = GetLineHeight(item); //dc.GetCharHeight() + 6;
3475
3476     Refresh(true, &rect);
3477 }
3478
3479 void wxGenericTreeCtrl::RefreshSelected()
3480 {
3481     if (m_freezeCount) return;
3482
3483     // TODO: this is awfully inefficient, we should keep the list of all
3484     //       selected items internally, should be much faster
3485     if ( m_anchor )
3486         RefreshSelectedUnder(m_anchor);
3487 }
3488
3489 void wxGenericTreeCtrl::RefreshSelectedUnder(wxGenericTreeItem *item)
3490 {
3491     if (m_freezeCount) return;
3492
3493     if ( item->IsSelected() )
3494         RefreshLine(item);
3495
3496     const wxArrayGenericTreeItems& children = item->GetChildren();
3497     size_t count = children.GetCount();
3498     for ( size_t n = 0; n < count; n++ )
3499     {
3500         RefreshSelectedUnder(children[n]);
3501     }
3502 }
3503
3504 void wxGenericTreeCtrl::Freeze()
3505 {
3506     m_freezeCount++;
3507 }
3508
3509 void wxGenericTreeCtrl::Thaw()
3510 {
3511     wxCHECK_RET( m_freezeCount > 0, _T("thawing unfrozen tree control?") );
3512
3513     if ( !--m_freezeCount )
3514     {
3515         Refresh();
3516     }
3517 }
3518
3519 // ----------------------------------------------------------------------------
3520 // changing colours: we need to refresh the tree control
3521 // ----------------------------------------------------------------------------
3522
3523 bool wxGenericTreeCtrl::SetBackgroundColour(const wxColour& colour)
3524 {
3525     if ( !wxWindow::SetBackgroundColour(colour) )
3526         return false;
3527
3528     if (m_freezeCount) return true;
3529
3530     Refresh();
3531
3532     return true;
3533 }
3534
3535 bool wxGenericTreeCtrl::SetForegroundColour(const wxColour& colour)
3536 {
3537     if ( !wxWindow::SetForegroundColour(colour) )
3538         return false;
3539
3540     if (m_freezeCount) return true;
3541
3542     Refresh();
3543
3544     return true;
3545 }
3546
3547 // Process the tooltip event, to speed up event processing.
3548 // Doesn't actually get a tooltip.
3549 void wxGenericTreeCtrl::OnGetToolTip( wxTreeEvent &event )
3550 {
3551     event.Veto();
3552 }
3553
3554
3555 // NOTE: If using the wxListBox visual attributes works everywhere then this can
3556 // be removed, as well as the #else case below.
3557 #define _USE_VISATTR 0
3558
3559 #if _USE_VISATTR
3560 #include "wx/listbox.h"
3561 #endif
3562
3563 //static
3564 wxVisualAttributes
3565 #if _USE_VISATTR
3566 wxGenericTreeCtrl::GetClassDefaultAttributes(wxWindowVariant variant)
3567 #else
3568 wxGenericTreeCtrl::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
3569 #endif
3570 {
3571 #if _USE_VISATTR
3572     // Use the same color scheme as wxListBox
3573     return wxListBox::GetClassDefaultAttributes(variant);
3574 #else
3575     wxVisualAttributes attr;
3576     attr.colFg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
3577     attr.colBg = wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOX);
3578     attr.font  = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
3579     return attr;
3580 #endif
3581 }
3582
3583 #if WXWIN_COMPATIBILITY_2_4
3584
3585 int wxGenericTreeCtrl::GetItemSelectedImage(const wxTreeItemId& item) const
3586 {
3587     return GetItemImage(item, wxTreeItemIcon_Selected);
3588 }
3589
3590 void wxGenericTreeCtrl::SetItemSelectedImage(const wxTreeItemId& item, int image)
3591 {
3592     SetItemImage(item, image, wxTreeItemIcon_Selected);
3593 }
3594
3595 #endif // WXWIN_COMPATIBILITY_2_4
3596
3597 #endif // wxUSE_TREECTRL