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