src/generic/treectlg.cpp

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