src/generic/treectlg.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        treectlg.cpp
   3 // Purpose:     generic tree control implementation
   4 // Author:      Robert Roebling
   5 // Created:     01/02/97
   6 // Modified:    22/10/98 - almost total rewrite, simpler interface (VZ)
   7 // Id:          $Id$
   8 // Copyright:   (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // =============================================================================
  13 // declarations
  14 // =============================================================================
  15
  16 // -----------------------------------------------------------------------------
  17 // headers
  18 // -----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21   #pragma implementation "treectlg.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #if wxUSE_TREECTRL
  32
  33 #include "wx/generic/treectlg.h"
  34 #include "wx/imaglist.h"
  35 #include "wx/settings.h"
  36 #include "wx/log.h"
  37 #include "wx/intl.h"
  38 #include "wx/dynarray.h"
  39 #include "wx/arrimpl.cpp"
  40 #include "wx/dcclient.h"
  41 #include "wx/msgdlg.h"
  42
  43 // -----------------------------------------------------------------------------
  44 // array types
  45 // -----------------------------------------------------------------------------
  46
  47 class WXDLLEXPORT wxGenericTreeItem;
  48
  49 WX_DEFINE_EXPORTED_ARRAY(wxGenericTreeItem *, wxArrayGenericTreeItems);
  50 //WX_DEFINE_OBJARRAY(wxArrayTreeItemIds);
  51
  52 // ----------------------------------------------------------------------------
  53 // constants
  54 // ----------------------------------------------------------------------------
  55
  56 static const int NO_IMAGE = -1;
  57
  58 #define PIXELS_PER_UNIT 10
  59
  60 // -----------------------------------------------------------------------------
  61 // private classes
  62 // -----------------------------------------------------------------------------
  63
  64 // timer used for enabling in-place edit
  65 class WXDLLEXPORT wxTreeRenameTimer: public wxTimer
  66 {
  67 public:
  68     wxTreeRenameTimer( wxGenericTreeCtrl *owner );
  69
  70     void Notify();
  71
  72 private:
  73     wxGenericTreeCtrl   *m_owner;
  74 };
  75
  76 // control used for in-place edit
  77 class WXDLLEXPORT wxTreeTextCtrl: public wxTextCtrl
  78 {
  79 public:
  80     wxTreeTextCtrl() { }
  81     wxTreeTextCtrl( wxWindow *parent,
  82                     const wxWindowID id,
  83                     bool *accept,
  84                     wxString *res,
  85                     wxGenericTreeCtrl *owner,
  86                     const wxString &value = wxEmptyString,
  87                     const wxPoint &pos = wxDefaultPosition,
  88                     const wxSize &size = wxDefaultSize,
  89                     int style = wxSIMPLE_BORDER,
  90                     const wxValidator& validator = wxDefaultValidator,
  91                     const wxString &name = wxTextCtrlNameStr );
  92
  93     void OnChar( wxKeyEvent &event );
  94     void OnKeyUp( wxKeyEvent &event );
  95     void OnKillFocus( wxFocusEvent &event );
  96
  97 private:
  98     bool               *m_accept;
  99     wxString           *m_res;
 100     wxGenericTreeCtrl         *m_owner;
 101     wxString            m_startValue;
 102
 103     DECLARE_EVENT_TABLE()
 104     DECLARE_DYNAMIC_CLASS(wxTreeTextCtrl);
 105 };
 106
 107 // a tree item
 108 class WXDLLEXPORT wxGenericTreeItem
 109 {
 110 public:
 111     // ctors & dtor
 112     wxGenericTreeItem() { m_data = NULL; }
 113     wxGenericTreeItem( wxGenericTreeItem *parent,
 114             const wxString& text,
 115             wxDC& dc,
 116             int image, int selImage,
 117             wxTreeItemData *data );
 118
 119     ~wxGenericTreeItem();
 120
 121     // trivial accessors
 122     wxArrayGenericTreeItems& GetChildren() { return m_children; }
 123
 124     const wxString& GetText() const { return m_text; }
 125     int GetImage(wxTreeItemIcon which = wxTreeItemIcon_Normal) const
 126         { return m_images[which]; }
 127     wxTreeItemData *GetData() const { return m_data; }
 128
 129     // returns the current image for the item (depending on its
 130     // selected/expanded/whatever state)
 131     int GetCurrentImage() const;
 132
 133     void SetText( const wxString &text );
 134     void SetImage(int image, wxTreeItemIcon which) { m_images[which] = image; }
 135     void SetData(wxTreeItemData *data) { m_data = data; }
 136
 137     void SetHasPlus(bool has = TRUE) { m_hasPlus = has; }
 138
 139     void SetBold(bool bold) { m_isBold = bold; }
 140
 141     int GetX() const { return m_x; }
 142     int GetY() const { return m_y; }
 143
 144     void SetX(int x) { m_x = x; }
 145     void SetY(int y) { m_y = y; }
 146
 147     int  GetHeight() const { return m_height; }
 148     int  GetWidth()  const { return m_width; }
 149
 150     void SetHeight(int h) { m_height = h; }
 151     void SetWidth(int w) { m_width = w; }
 152
 153
 154     wxGenericTreeItem *GetParent() const { return m_parent; }
 155
 156     // operations
 157         // deletes all children notifying the treectrl about it if !NULL
 158         // pointer given
 159     void DeleteChildren(wxGenericTreeCtrl *tree = NULL);
 160         // FIXME don't know what is it for
 161     void Reset();
 162
 163     // get count of all children (and grand children if 'recursively')
 164     size_t GetChildrenCount(bool recursively = TRUE) const;
 165
 166     void Insert(wxGenericTreeItem *child, size_t index)
 167     { m_children.Insert(child, index); }
 168
 169     void SetCross( int x, int y );
 170     void GetSize( int &x, int &y, const wxGenericTreeCtrl* );
 171
 172         // return the item at given position (or NULL if no item), onButton is
 173         // TRUE if the point belongs to the item's button, otherwise it lies
 174         // on the button's label
 175     wxGenericTreeItem *HitTest( const wxPoint& point, const wxGenericTreeCtrl *, int &flags);
 176
 177     void Expand() { m_isCollapsed = FALSE; }
 178     void Collapse() { m_isCollapsed = TRUE; }
 179
 180     void SetHilight( bool set = TRUE ) { m_hasHilight = set; }
 181
 182     // status inquiries
 183     bool HasChildren() const { return !m_children.IsEmpty(); }
 184     bool IsSelected()  const { return m_hasHilight != 0; }
 185     bool IsExpanded()  const { return !m_isCollapsed; }
 186     bool HasPlus()     const { return m_hasPlus || HasChildren(); }
 187     bool IsBold()      const { return m_isBold != 0; }
 188
 189     // attributes
 190         // get them - may be NULL
 191     wxTreeItemAttr *GetAttributes() const { return m_attr; }
 192         // get them ensuring that the pointer is not NULL
 193     wxTreeItemAttr& Attr()
 194     {
 195         if ( !m_attr )
 196             m_attr = new wxTreeItemAttr;
 197
 198         return *m_attr;
 199     }
 200
 201 private:
 202     wxString            m_text;
 203
 204     // tree ctrl images for the normal, selected, expanded and
 205     // expanded+selected states
 206     int                 m_images[wxTreeItemIcon_Max];
 207
 208     wxTreeItemData     *m_data;
 209
 210     // use bitfields to save size
 211     int                 m_isCollapsed :1;
 212     int                 m_hasHilight  :1; // same as focused
 213     int                 m_hasPlus     :1; // used for item which doesn't have
 214                                           // children but has a [+] button
 215     int                 m_isBold      :1; // render the label in bold font
 216
 217     wxCoord             m_x, m_y;
 218     wxCoord             m_height, m_width;
 219     int                 m_xCross, m_yCross;
 220     int                 m_level;
 221
 222     wxArrayGenericTreeItems m_children;
 223     wxGenericTreeItem  *m_parent;
 224
 225     wxTreeItemAttr     *m_attr;
 226 };
 227
 228 // =============================================================================
 229 // implementation
 230 // =============================================================================
 231
 232 // ----------------------------------------------------------------------------
 233 // private functions
 234 // ----------------------------------------------------------------------------
 235
 236 // translate the key or mouse event flags to the type of selection we're
 237 // dealing with
 238 static void EventFlagsToSelType(long style,
 239                                 bool shiftDown,
 240                                 bool ctrlDown,
 241                                 bool &is_multiple,
 242                                 bool &extended_select,
 243                                 bool &unselect_others)
 244 {
 245     is_multiple = (style & wxTR_MULTIPLE) != 0;
 246     extended_select = shiftDown && is_multiple;
 247     unselect_others = !(extended_select || (ctrlDown && is_multiple));
 248 }
 249
 250 // -----------------------------------------------------------------------------
 251 // wxTreeRenameTimer (internal)
 252 // -----------------------------------------------------------------------------
 253
 254 wxTreeRenameTimer::wxTreeRenameTimer( wxGenericTreeCtrl *owner )
 255 {
 256     m_owner = owner;
 257 }
 258
 259 void wxTreeRenameTimer::Notify()
 260 {
 261     m_owner->OnRenameTimer();
 262 }
 263
 264 //-----------------------------------------------------------------------------
 265 // wxTreeTextCtrl (internal)
 266 //-----------------------------------------------------------------------------
 267
 268 IMPLEMENT_DYNAMIC_CLASS(wxTreeTextCtrl,wxTextCtrl);
 269
 270 BEGIN_EVENT_TABLE(wxTreeTextCtrl,wxTextCtrl)
 271     EVT_CHAR           (wxTreeTextCtrl::OnChar)
 272     EVT_KEY_UP         (wxTreeTextCtrl::OnKeyUp)
 273     EVT_KILL_FOCUS     (wxTreeTextCtrl::OnKillFocus)
 274 END_EVENT_TABLE()
 275
 276 wxTreeTextCtrl::wxTreeTextCtrl( wxWindow *parent,
 277                                 const wxWindowID id,
 278                                 bool *accept,
 279                                 wxString *res,
 280                                 wxGenericTreeCtrl *owner,
 281                                 const wxString &value,
 282                                 const wxPoint &pos,
 283                                 const wxSize &size,
 284                                 int style,
 285                                 const wxValidator& validator,
 286                                 const wxString &name )
 287               : wxTextCtrl( parent, id, value, pos, size, style, validator, name )
 288 {
 289     m_res = res;
 290     m_accept = accept;
 291     m_owner = owner;
 292     (*m_accept) = FALSE;
 293     (*m_res) = wxEmptyString;
 294     m_startValue = value;
 295 }
 296
 297 void wxTreeTextCtrl::OnChar( wxKeyEvent &event )
 298 {
 299     if (event.m_keyCode == WXK_RETURN)
 300     {
 301         (*m_accept) = TRUE;
 302         (*m_res) = GetValue();
 303
 304         if (!wxPendingDelete.Member(this))
 305             wxPendingDelete.Append(this);
 306
 307         if ((*m_accept) && ((*m_res) != m_startValue))
 308             m_owner->OnRenameAccept();
 309
 310         return;
 311     }
 312     if (event.m_keyCode == WXK_ESCAPE)
 313     {
 314         (*m_accept) = FALSE;
 315         (*m_res) = "";
 316
 317         if (!wxPendingDelete.Member(this))
 318             wxPendingDelete.Append(this);
 319
 320         return;
 321     }
 322     event.Skip();
 323 }
 324
 325 void wxTreeTextCtrl::OnKeyUp( wxKeyEvent &event )
 326 {
 327     // auto-grow the textctrl:
 328     wxSize parentSize = m_owner->GetSize();
 329     wxPoint myPos = GetPosition();
 330     wxSize mySize = GetSize();
 331     int sx, sy;
 332     GetTextExtent(GetValue() + _T("MM"), &sx, &sy);
 333     if (myPos.x + sx > parentSize.x) sx = parentSize.x - myPos.x;
 334     if (mySize.x > sx) sx = mySize.x;
 335     SetSize(sx, -1);
 336
 337     event.Skip();
 338 }
 339
 340 void wxTreeTextCtrl::OnKillFocus( wxFocusEvent &WXUNUSED(event) )
 341 {
 342     if (!wxPendingDelete.Member(this))
 343         wxPendingDelete.Append(this);
 344
 345     if ((*m_accept) && ((*m_res) != m_startValue))
 346         m_owner->OnRenameAccept();
 347 }
 348
 349 #if 0
 350 // -----------------------------------------------------------------------------
 351 // wxTreeEvent
 352 // -----------------------------------------------------------------------------
 353
 354 IMPLEMENT_DYNAMIC_CLASS(wxTreeEvent, wxNotifyEvent)
 355
 356 wxTreeEvent::wxTreeEvent( wxEventType commandType, int id )
 357            : wxNotifyEvent( commandType, id )
 358 {
 359     m_code = 0;
 360     m_itemOld = (wxGenericTreeItem *)NULL;
 361 }
 362 #endif
 363
 364 // -----------------------------------------------------------------------------
 365 // wxGenericTreeItem
 366 // -----------------------------------------------------------------------------
 367
 368 wxGenericTreeItem::wxGenericTreeItem(wxGenericTreeItem *parent,
 369                                      const wxString& text,
 370                                      wxDC& WXUNUSED(dc),
 371                                      int image, int selImage,
 372                                      wxTreeItemData *data)
 373                  : m_text(text)
 374 {
 375     m_images[wxTreeItemIcon_Normal] = image;
 376     m_images[wxTreeItemIcon_Selected] = selImage;
 377     m_images[wxTreeItemIcon_Expanded] = NO_IMAGE;
 378     m_images[wxTreeItemIcon_SelectedExpanded] = NO_IMAGE;
 379
 380     m_data = data;
 381     m_x = m_y = 0;
 382     m_xCross = m_yCross = 0;
 383
 384     m_level = 0;
 385
 386     m_isCollapsed = TRUE;
 387     m_hasHilight = FALSE;
 388     m_hasPlus = FALSE;
 389     m_isBold = FALSE;
 390
 391     m_parent = parent;
 392
 393     m_attr = (wxTreeItemAttr *)NULL;
 394
 395     // We don't know the height here yet.
 396     m_width = 0;
 397     m_height = 0;
 398 }
 399
 400 wxGenericTreeItem::~wxGenericTreeItem()
 401 {
 402     delete m_data;
 403
 404     delete m_attr;
 405
 406     wxASSERT_MSG( m_children.IsEmpty(),
 407                   wxT("please call DeleteChildren() before deleting the item") );
 408 }
 409
 410 void wxGenericTreeItem::DeleteChildren(wxGenericTreeCtrl *tree)
 411 {
 412     size_t count = m_children.Count();
 413     for ( size_t n = 0; n < count; n++ )
 414     {
 415         wxGenericTreeItem *child = m_children[n];
 416         if (tree)
 417             tree->SendDeleteEvent(child);
 418
 419         child->DeleteChildren(tree);
 420         delete child;
 421     }
 422
 423     m_children.Empty();
 424 }
 425
 426 void wxGenericTreeItem::SetText( const wxString &text )
 427 {
 428     m_text = text;
 429 }
 430
 431 void wxGenericTreeItem::Reset()
 432 {
 433     m_text.Empty();
 434     for ( int i = 0; i < wxTreeItemIcon_Max; i++ )
 435     {
 436         m_images[i] = NO_IMAGE;
 437     }
 438
 439     m_data = NULL;
 440     m_x = m_y =
 441     m_height = m_width = 0;
 442     m_xCross =
 443     m_yCross = 0;
 444
 445     m_level = 0;
 446
 447     DeleteChildren();
 448     m_isCollapsed = TRUE;
 449
 450     m_parent = (wxGenericTreeItem *)NULL;
 451 }
 452
 453 size_t wxGenericTreeItem::GetChildrenCount(bool recursively) const
 454 {
 455     size_t count = m_children.Count();
 456     if ( !recursively )
 457         return count;
 458
 459     size_t total = count;
 460     for (size_t n = 0; n < count; ++n)
 461     {
 462         total += m_children[n]->GetChildrenCount();
 463     }
 464
 465     return total;
 466 }
 467
 468 void wxGenericTreeItem::SetCross( int x, int y )
 469 {
 470     m_xCross = x;
 471     m_yCross = y;
 472 }
 473
 474 void wxGenericTreeItem::GetSize( int &x, int &y, const wxGenericTreeCtrl *theTree )
 475 {
 476     int bottomY=m_y+theTree->GetLineHeight(this);
 477     if ( y < bottomY ) y = bottomY;
 478     int width = m_x +  m_width;
 479     if ( x < width ) x = width;
 480
 481     if (IsExpanded())
 482     {
 483         size_t count = m_children.Count();
 484         for ( size_t n = 0; n < count; ++n )
 485         {
 486             m_children[n]->GetSize( x, y, theTree );
 487         }
 488     }
 489 }
 490
 491 wxGenericTreeItem *wxGenericTreeItem::HitTest( const wxPoint& point,
 492                                                const wxGenericTreeCtrl *theTree,
 493                                                int &flags)
 494 {
 495     if ((point.y > m_y) && (point.y < m_y + theTree->GetLineHeight(this)))
 496     {
 497         if (point.y < m_y+theTree->GetLineHeight(this)/2 )
 498             flags |= wxTREE_HITTEST_ONITEMUPPERPART;
 499         else
 500             flags |= wxTREE_HITTEST_ONITEMLOWERPART;
 501
 502         // 5 is the size of the plus sign
 503         if ((point.x > m_xCross-5) && (point.x < m_xCross+5) &&
 504             (point.y > m_yCross-5) && (point.y < m_yCross+5) &&
 505             (IsExpanded() || HasPlus()))
 506         {
 507             flags|=wxTREE_HITTEST_ONITEMBUTTON;
 508             return this;
 509         }
 510
 511         if ((point.x >= m_x) && (point.x <= m_x+m_width))
 512         {
 513             int image_w = -1;
 514             int image_h;
 515
 516             // assuming every image (normal and selected ) has the same size !
 517             if ( (GetImage() != NO_IMAGE) && theTree->m_imageListNormal )
 518                 theTree->m_imageListNormal->GetSize(GetImage(), image_w, image_h);
 519
 520             if ((image_w != -1) && (point.x <= m_x + image_w + 1))
 521                 flags |= wxTREE_HITTEST_ONITEMICON;
 522             else
 523                 flags |= wxTREE_HITTEST_ONITEMLABEL;
 524
 525             return this;
 526         }
 527
 528         if (point.x < m_x)
 529             flags |= wxTREE_HITTEST_ONITEMINDENT;
 530         if (point.x > m_x+m_width)
 531             flags |= wxTREE_HITTEST_ONITEMRIGHT;
 532
 533         return this;
 534     }
 535     else
 536     {
 537         if (!m_isCollapsed)
 538         {
 539             size_t count = m_children.Count();
 540             for ( size_t n = 0; n < count; n++ )
 541             {
 542                 wxGenericTreeItem *res = m_children[n]->HitTest( point, theTree, flags );
 543                 if ( res != NULL )
 544                     return res;
 545             }
 546         }
 547     }
 548
 549     flags|=wxTREE_HITTEST_NOWHERE;
 550
 551     return (wxGenericTreeItem*) NULL;
 552 }
 553
 554 int wxGenericTreeItem::GetCurrentImage() const
 555 {
 556     int image = NO_IMAGE;
 557     if ( IsExpanded() )
 558     {
 559         if ( IsSelected() )
 560         {
 561             image = GetImage(wxTreeItemIcon_SelectedExpanded);
 562         }
 563
 564         if ( image == NO_IMAGE )
 565         {
 566             // we usually fall back to the normal item, but try just the
 567             // expanded one (and not selected) first in this case
 568             image = GetImage(wxTreeItemIcon_Expanded);
 569         }
 570     }
 571     else // not expanded
 572     {
 573         if ( IsSelected() )
 574             image = GetImage(wxTreeItemIcon_Selected);
 575     }
 576
 577     // may be it doesn't have the specific image we want, try the default one
 578     // instead
 579     if ( image == NO_IMAGE )
 580     {
 581         image = GetImage();
 582     }
 583
 584     return image;
 585 }
 586
 587 // -----------------------------------------------------------------------------
 588 // wxGenericTreeCtrl implementation
 589 // -----------------------------------------------------------------------------
 590
 591 IMPLEMENT_DYNAMIC_CLASS(wxGenericTreeCtrl, wxScrolledWindow)
 592
 593 BEGIN_EVENT_TABLE(wxGenericTreeCtrl,wxScrolledWindow)
 594     EVT_PAINT          (wxGenericTreeCtrl::OnPaint)
 595     EVT_MOUSE_EVENTS   (wxGenericTreeCtrl::OnMouse)
 596     EVT_CHAR           (wxGenericTreeCtrl::OnChar)
 597     EVT_SET_FOCUS      (wxGenericTreeCtrl::OnSetFocus)
 598     EVT_KILL_FOCUS     (wxGenericTreeCtrl::OnKillFocus)
 599     EVT_IDLE           (wxGenericTreeCtrl::OnIdle)
 600 END_EVENT_TABLE()
 601
 602 #if !defined(__WXMSW__) || defined(__WIN16__)
 603 /*
 604  * wxTreeCtrl has to be a real class or we have problems with
 605  * the run-time information.
 606  */
 607
 608 IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxGenericTreeCtrl)
 609 #endif
 610
 611 // -----------------------------------------------------------------------------
 612 // construction/destruction
 613 // -----------------------------------------------------------------------------
 614
 615 void wxGenericTreeCtrl::Init()
 616 {
 617     m_current =
 618     m_key_current =
 619     m_anchor = (wxGenericTreeItem *) NULL;
 620     m_hasFocus = FALSE;
 621     m_dirty = FALSE;
 622
 623     m_xScroll = 0;
 624     m_yScroll = 0;
 625     m_lineHeight = 10;
 626     m_indent = 15;
 627     m_spacing = 18;
 628
 629     m_hilightBrush = new wxBrush
 630     (
 631       wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHT),
 632       wxSOLID
 633     );
 634
 635     m_imageListNormal =
 636     m_imageListState = (wxImageList *) NULL;
 637     m_ownsImageListNormal =
 638     m_ownsImageListState = FALSE;
 639
 640     m_dragCount = 0;
 641     m_isDragging = FALSE;
 642     m_dropTarget =
 643     m_oldSelection = (wxGenericTreeItem *)NULL;
 644
 645     m_renameTimer = new wxTreeRenameTimer( this );
 646     m_lastOnSame = FALSE;
 647
 648     m_normalFont = wxSystemSettings::GetSystemFont( wxSYS_DEFAULT_GUI_FONT );
 649     m_boldFont = wxFont( m_normalFont.GetPointSize(),
 650                             m_normalFont.GetFamily(),
 651                             m_normalFont.GetStyle(),
 652                             wxBOLD,
 653                             m_normalFont.GetUnderlined());
 654 }
 655
 656 bool wxGenericTreeCtrl::Create(wxWindow *parent, wxWindowID id,
 657                         const wxPoint& pos, const wxSize& size,
 658                         long style,
 659                         const wxValidator &validator,
 660                         const wxString& name )
 661 {
 662     wxScrolledWindow::Create( parent, id, pos, size, style|wxHSCROLL|wxVSCROLL, name );
 663
 664 #if wxUSE_VALIDATORS
 665     SetValidator( validator );
 666 #endif
 667
 668     SetBackgroundColour( wxSystemSettings::GetSystemColour( wxSYS_COLOUR_LISTBOX ) );
 669
 670 //  m_dottedPen = wxPen( "grey", 0, wxDOT );  too slow under XFree86
 671     m_dottedPen = wxPen( "grey", 0, 0 );
 672
 673     return TRUE;
 674 }
 675
 676 wxGenericTreeCtrl::~wxGenericTreeCtrl()
 677 {
 678     wxDELETE( m_hilightBrush );
 679
 680     DeleteAllItems();
 681
 682     delete m_renameTimer;
 683     if (m_ownsImageListNormal) delete m_imageListNormal;
 684     if (m_ownsImageListState) delete m_imageListState;
 685 }
 686
 687 // -----------------------------------------------------------------------------
 688 // accessors
 689 // -----------------------------------------------------------------------------
 690
 691 size_t wxGenericTreeCtrl::GetCount() const
 692 {
 693     return m_anchor == NULL ? 0u : m_anchor->GetChildrenCount();
 694 }
 695
 696 void wxGenericTreeCtrl::SetIndent(unsigned int indent)
 697 {
 698     m_indent = indent;
 699     m_dirty = TRUE;
 700 }
 701
 702 void wxGenericTreeCtrl::SetSpacing(unsigned int spacing)
 703 {
 704     m_spacing = spacing;
 705     m_dirty = TRUE;
 706 }
 707
 708 size_t wxGenericTreeCtrl::GetChildrenCount(const wxTreeItemId& item, bool recursively)
 709 {
 710     wxCHECK_MSG( item.IsOk(), 0u, wxT("invalid tree item") );
 711
 712     return ((wxGenericTreeItem*) item.m_pItem)->GetChildrenCount(recursively);
 713 }
 714
 715 // -----------------------------------------------------------------------------
 716 // functions to work with tree items
 717 // -----------------------------------------------------------------------------
 718
 719 wxString wxGenericTreeCtrl::GetItemText(const wxTreeItemId& item) const
 720 {
 721     wxCHECK_MSG( item.IsOk(), wxT(""), wxT("invalid tree item") );
 722
 723     return ((wxGenericTreeItem*) item.m_pItem)->GetText();
 724 }
 725
 726 int wxGenericTreeCtrl::GetItemImage(const wxTreeItemId& item,
 727                              wxTreeItemIcon which) const
 728 {
 729     wxCHECK_MSG( item.IsOk(), -1, wxT("invalid tree item") );
 730
 731     return ((wxGenericTreeItem*) item.m_pItem)->GetImage(which);
 732 }
 733
 734 wxTreeItemData *wxGenericTreeCtrl::GetItemData(const wxTreeItemId& item) const
 735 {
 736     wxCHECK_MSG( item.IsOk(), NULL, wxT("invalid tree item") );
 737
 738     return ((wxGenericTreeItem*) item.m_pItem)->GetData();
 739 }
 740
 741 void wxGenericTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text)
 742 {
 743     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
 744
 745     wxClientDC dc(this);
 746     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
 747     pItem->SetText(text);
 748     CalculateSize(pItem, dc);
 749     RefreshLine(pItem);
 750 }
 751
 752 void wxGenericTreeCtrl::SetItemImage(const wxTreeItemId& item,
 753                               int image,
 754                               wxTreeItemIcon which)
 755 {
 756     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
 757
 758     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
 759     pItem->SetImage(image, which);
 760
 761     wxClientDC dc(this);
 762     CalculateSize(pItem, dc);
 763     RefreshLine(pItem);
 764 }
 765
 766 void wxGenericTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data)
 767 {
 768     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
 769
 770     ((wxGenericTreeItem*) item.m_pItem)->SetData(data);
 771 }
 772
 773 void wxGenericTreeCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
 774 {
 775     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
 776
 777     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
 778     pItem->SetHasPlus(has);
 779     RefreshLine(pItem);
 780 }
 781
 782 void wxGenericTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
 783 {
 784     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
 785
 786     // avoid redrawing the tree if no real change
 787     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
 788     if ( pItem->IsBold() != bold )
 789     {
 790         pItem->SetBold(bold);
 791         RefreshLine(pItem);
 792     }
 793 }
 794
 795 void wxGenericTreeCtrl::SetItemTextColour(const wxTreeItemId& item,
 796                                    const wxColour& col)
 797 {
 798     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
 799
 800     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
 801     pItem->Attr().SetTextColour(col);
 802     RefreshLine(pItem);
 803 }
 804
 805 void wxGenericTreeCtrl::SetItemBackgroundColour(const wxTreeItemId& item,
 806                                          const wxColour& col)
 807 {
 808     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
 809
 810     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
 811     pItem->Attr().SetBackgroundColour(col);
 812     RefreshLine(pItem);
 813 }
 814
 815 void wxGenericTreeCtrl::SetItemFont(const wxTreeItemId& item, const wxFont& font)
 816 {
 817     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
 818
 819     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
 820     pItem->Attr().SetFont(font);
 821     RefreshLine(pItem);
 822 }
 823
 824 bool wxGenericTreeCtrl::SetFont( const wxFont &font )
 825 {
 826     wxScrolledWindow::SetFont(font);
 827
 828     m_normalFont = font ;
 829     m_boldFont = wxFont( m_normalFont.GetPointSize(),
 830                             m_normalFont.GetFamily(),
 831                             m_normalFont.GetStyle(),
 832                             wxBOLD,
 833                             m_normalFont.GetUnderlined());
 834
 835     return TRUE;
 836 }
 837
 838
 839 // -----------------------------------------------------------------------------
 840 // item status inquiries
 841 // -----------------------------------------------------------------------------
 842
 843 bool wxGenericTreeCtrl::IsVisible(const wxTreeItemId& item) const
 844 {
 845     wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
 846
 847     // An item is only visible if it's not a descendant of a collapsed item
 848     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
 849     wxGenericTreeItem* parent = pItem->GetParent();
 850     while (parent)
 851     {
 852         if (!parent->IsExpanded())
 853             return FALSE;
 854         parent = parent->GetParent();
 855     }
 856
 857     int startX, startY;
 858     GetViewStart(& startX, & startY);
 859
 860     wxSize clientSize = GetClientSize();
 861
 862     wxRect rect;
 863     if (!GetBoundingRect(item, rect))
 864         return FALSE;
 865     if (rect.GetWidth() == 0 || rect.GetHeight() == 0)
 866         return FALSE;
 867     if (rect.GetBottom() < 0 || rect.GetTop() > clientSize.y)
 868         return FALSE;
 869     if (rect.GetRight() < 0 || rect.GetLeft() > clientSize.x)
 870         return FALSE;
 871
 872     return TRUE;
 873 }
 874
 875 bool wxGenericTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const
 876 {
 877     wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
 878
 879     return !((wxGenericTreeItem*) item.m_pItem)->GetChildren().IsEmpty();
 880 }
 881
 882 bool wxGenericTreeCtrl::IsExpanded(const wxTreeItemId& item) const
 883 {
 884     wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
 885
 886     return ((wxGenericTreeItem*) item.m_pItem)->IsExpanded();
 887 }
 888
 889 bool wxGenericTreeCtrl::IsSelected(const wxTreeItemId& item) const
 890 {
 891     wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
 892
 893     return ((wxGenericTreeItem*) item.m_pItem)->IsSelected();
 894 }
 895
 896 bool wxGenericTreeCtrl::IsBold(const wxTreeItemId& item) const
 897 {
 898     wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
 899
 900     return ((wxGenericTreeItem*) item.m_pItem)->IsBold();
 901 }
 902
 903 // -----------------------------------------------------------------------------
 904 // navigation
 905 // -----------------------------------------------------------------------------
 906
 907 wxTreeItemId wxGenericTreeCtrl::GetParent(const wxTreeItemId& item) const
 908 {
 909   wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
 910
 911   return ((wxGenericTreeItem*) item.m_pItem)->GetParent();
 912 }
 913
 914 wxTreeItemId wxGenericTreeCtrl::GetFirstChild(const wxTreeItemId& item, long& cookie) const
 915 {
 916   wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
 917
 918   cookie = 0;
 919   return GetNextChild(item, cookie);
 920 }
 921
 922 wxTreeItemId wxGenericTreeCtrl::GetNextChild(const wxTreeItemId& item, long& cookie) const
 923 {
 924   wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
 925
 926   wxArrayGenericTreeItems& children = ((wxGenericTreeItem*) item.m_pItem)->GetChildren();
 927   if ( (size_t)cookie < children.Count() )
 928   {
 929     return children.Item((size_t)cookie++);
 930   }
 931   else
 932   {
 933     // there are no more of them
 934     return wxTreeItemId();
 935   }
 936 }
 937
 938 wxTreeItemId wxGenericTreeCtrl::GetLastChild(const wxTreeItemId& item) const
 939 {
 940   wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
 941
 942   wxArrayGenericTreeItems& children = ((wxGenericTreeItem*) item.m_pItem)->GetChildren();
 943   return (children.IsEmpty() ? wxTreeItemId() : wxTreeItemId(children.Last()));
 944 }
 945
 946 wxTreeItemId wxGenericTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
 947 {
 948   wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
 949
 950   wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
 951   wxGenericTreeItem *parent = i->GetParent();
 952   if ( parent == NULL )
 953   {
 954     // root item doesn't have any siblings
 955     return wxTreeItemId();
 956   }
 957
 958   wxArrayGenericTreeItems& siblings = parent->GetChildren();
 959   int index = siblings.Index(i);
 960   wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
 961
 962   size_t n = (size_t)(index + 1);
 963   return n == siblings.Count() ? wxTreeItemId() : wxTreeItemId(siblings[n]);
 964 }
 965
 966 wxTreeItemId wxGenericTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const
 967 {
 968   wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
 969
 970   wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
 971   wxGenericTreeItem *parent = i->GetParent();
 972   if ( parent == NULL )
 973   {
 974     // root item doesn't have any siblings
 975     return wxTreeItemId();
 976   }
 977
 978   wxArrayGenericTreeItems& siblings = parent->GetChildren();
 979   int index = siblings.Index(i);
 980   wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
 981
 982   return index == 0 ? wxTreeItemId()
 983                     : wxTreeItemId(siblings[(size_t)(index - 1)]);
 984 }
 985
 986 // Only for internal use right now, but should probably be public
 987 wxTreeItemId wxGenericTreeCtrl::GetNext(const wxTreeItemId& item) const
 988 {
 989   wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
 990
 991   wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
 992
 993   // First see if there are any children.
 994   wxArrayGenericTreeItems& children = i->GetChildren();
 995   if (children.GetCount() > 0)
 996   {
 997      return children.Item(0);
 998   }
 999   else
1000   {
1001      // Try a sibling of this or ancestor instead
1002      wxTreeItemId p = item;
1003      wxTreeItemId toFind;
1004      do
1005      {
1006         toFind = GetNextSibling(p);
1007         p = GetParent(p);
1008      } while (p.IsOk() && !toFind.IsOk());
1009      return toFind;
1010   }
1011 }
1012
1013 wxTreeItemId wxGenericTreeCtrl::GetPrev(const wxTreeItemId& item) const
1014 {
1015   wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1016
1017   wxFAIL_MSG(wxT("not implemented"));
1018
1019   return wxTreeItemId();
1020 }
1021
1022 wxTreeItemId wxGenericTreeCtrl::GetFirstVisibleItem() const
1023 {
1024   wxTreeItemId id = GetRootItem();
1025   if (!id.IsOk())
1026     return id;
1027
1028   do
1029   {
1030     if (IsVisible(id))
1031         return id;
1032     id = GetNext(id);
1033   } while (id.IsOk());
1034
1035   return wxTreeItemId();
1036 }
1037
1038 wxTreeItemId wxGenericTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
1039 {
1040   wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1041
1042   wxTreeItemId id = item;
1043   while (id.IsOk())
1044   {
1045       id = GetNext(id);
1046
1047       if (id.IsOk() && IsVisible(id))
1048           return id;
1049   }
1050   return wxTreeItemId();
1051 }
1052
1053 wxTreeItemId wxGenericTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
1054 {
1055   wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1056
1057   wxFAIL_MSG(wxT("not implemented"));
1058
1059   return wxTreeItemId();
1060 }
1061
1062 // -----------------------------------------------------------------------------
1063 // operations
1064 // -----------------------------------------------------------------------------
1065
1066 wxTreeItemId wxGenericTreeCtrl::DoInsertItem(const wxTreeItemId& parentId,
1067                                       size_t previous,
1068                                       const wxString& text,
1069                                       int image, int selImage,
1070                                       wxTreeItemData *data)
1071 {
1072     wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem;
1073     if ( !parent )
1074     {
1075         // should we give a warning here?
1076         return AddRoot(text, image, selImage, data);
1077     }
1078
1079     wxClientDC dc(this);
1080     wxGenericTreeItem *item =
1081         new wxGenericTreeItem( parent, text, dc, image, selImage, data );
1082
1083     if ( data != NULL )
1084     {
1085         data->m_pItem = (long) item;
1086     }
1087
1088     parent->Insert( item, previous );
1089
1090     m_dirty = TRUE;
1091
1092     return item;
1093 }
1094
1095 wxTreeItemId wxGenericTreeCtrl::AddRoot(const wxString& text,
1096                                  int image, int selImage,
1097                                  wxTreeItemData *data)
1098 {
1099     wxCHECK_MSG( !m_anchor, wxTreeItemId(), wxT("tree can have only one root") );
1100
1101     wxClientDC dc(this);
1102     m_anchor = new wxGenericTreeItem((wxGenericTreeItem *)NULL, text, dc,
1103                                    image, selImage, data);
1104     if ( data != NULL )
1105     {
1106         data->m_pItem = (long) m_anchor;
1107     }
1108
1109     if (!HasFlag(wxTR_MULTIPLE))
1110     {
1111         m_current = m_key_current = m_anchor;
1112         m_current->SetHilight( TRUE );
1113     }
1114
1115     m_dirty = TRUE;
1116
1117     return m_anchor;
1118 }
1119
1120 wxTreeItemId wxGenericTreeCtrl::PrependItem(const wxTreeItemId& parent,
1121                                      const wxString& text,
1122                                      int image, int selImage,
1123                                      wxTreeItemData *data)
1124 {
1125     return DoInsertItem(parent, 0u, text, image, selImage, data);
1126 }
1127
1128 wxTreeItemId wxGenericTreeCtrl::InsertItem(const wxTreeItemId& parentId,
1129                                     const wxTreeItemId& idPrevious,
1130                                     const wxString& text,
1131                                     int image, int selImage,
1132                                     wxTreeItemData *data)
1133 {
1134     wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem;
1135     if ( !parent )
1136     {
1137         // should we give a warning here?
1138         return AddRoot(text, image, selImage, data);
1139     }
1140
1141     int index = parent->GetChildren().Index((wxGenericTreeItem*) idPrevious.m_pItem);
1142     wxASSERT_MSG( index != wxNOT_FOUND,
1143                   wxT("previous item in wxGenericTreeCtrl::InsertItem() is not a sibling") );
1144
1145     return DoInsertItem(parentId, (size_t)++index, text, image, selImage, data);
1146 }
1147
1148 wxTreeItemId wxGenericTreeCtrl::InsertItem(const wxTreeItemId& parentId,
1149                                     size_t before,
1150                                     const wxString& text,
1151                                     int image, int selImage,
1152                                     wxTreeItemData *data)
1153 {
1154     wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem;
1155     if ( !parent )
1156     {
1157         // should we give a warning here?
1158         return AddRoot(text, image, selImage, data);
1159     }
1160
1161     return DoInsertItem(parentId, before, text, image, selImage, data);
1162 }
1163
1164 wxTreeItemId wxGenericTreeCtrl::AppendItem(const wxTreeItemId& parentId,
1165                                     const wxString& text,
1166                                     int image, int selImage,
1167                                     wxTreeItemData *data)
1168 {
1169     wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem;
1170     if ( !parent )
1171     {
1172         // should we give a warning here?
1173         return AddRoot(text, image, selImage, data);
1174     }
1175
1176     return DoInsertItem( parent, parent->GetChildren().Count(), text,
1177                          image, selImage, data);
1178 }
1179
1180 void wxGenericTreeCtrl::SendDeleteEvent(wxGenericTreeItem *item)
1181 {
1182     wxTreeEvent event( wxEVT_COMMAND_TREE_DELETE_ITEM, GetId() );
1183     event.m_item = (long) item;
1184     event.SetEventObject( this );
1185     ProcessEvent( event );
1186 }
1187
1188 void wxGenericTreeCtrl::DeleteChildren(const wxTreeItemId& itemId)
1189 {
1190     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1191     item->DeleteChildren(this);
1192
1193     m_dirty = TRUE;
1194 }
1195
1196 void wxGenericTreeCtrl::Delete(const wxTreeItemId& itemId)
1197 {
1198     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1199
1200     // don't stay with invalid m_key_current or we will crash in the next call
1201     // to OnChar()
1202     bool changeKeyCurrent = FALSE;
1203     wxGenericTreeItem *itemKey = m_key_current;
1204     while ( itemKey && !changeKeyCurrent )
1205     {
1206         if ( itemKey == item )
1207         {
1208             // m_key_current is a descendant of the item being deleted
1209             changeKeyCurrent = TRUE;
1210         }
1211         else
1212         {
1213             itemKey = itemKey->GetParent();
1214         }
1215     }
1216
1217     wxGenericTreeItem *parent = item->GetParent();
1218     if ( parent )
1219     {
1220         parent->GetChildren().Remove( item );  // remove by value
1221     }
1222
1223     if ( changeKeyCurrent )
1224     {
1225         // may be NULL or not
1226         m_key_current = parent;
1227     }
1228
1229     item->DeleteChildren(this);
1230     SendDeleteEvent(item);
1231     delete item;
1232
1233     m_dirty = TRUE;
1234 }
1235
1236 void wxGenericTreeCtrl::DeleteAllItems()
1237 {
1238     if ( m_anchor )
1239     {
1240         m_anchor->DeleteChildren(this);
1241         delete m_anchor;
1242
1243         m_anchor = NULL;
1244
1245         m_dirty = TRUE;
1246     }
1247 }
1248
1249 void wxGenericTreeCtrl::Expand(const wxTreeItemId& itemId)
1250 {
1251     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1252
1253     wxCHECK_RET( item, _T("invalid item in wxGenericTreeCtrl::Expand") );
1254
1255     if ( !item->HasPlus() )
1256         return;
1257
1258     if ( item->IsExpanded() )
1259         return;
1260
1261     wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_EXPANDING, GetId() );
1262     event.m_item = (long) item;
1263     event.SetEventObject( this );
1264
1265     if ( ProcessEvent( event ) && !event.IsAllowed() )
1266     {
1267         // cancelled by program
1268         return;
1269     }
1270
1271     item->Expand();
1272     CalculatePositions();
1273
1274     RefreshSubtree(item);
1275
1276     event.SetEventType(wxEVT_COMMAND_TREE_ITEM_EXPANDED);
1277     ProcessEvent( event );
1278 }
1279
1280 void wxGenericTreeCtrl::ExpandAll(const wxTreeItemId& item)
1281 {
1282     Expand(item);
1283     if ( IsExpanded(item) )
1284     {
1285         long cookie;
1286         wxTreeItemId child = GetFirstChild(item, cookie);
1287         while ( child.IsOk() )
1288         {
1289             ExpandAll(child);
1290
1291             child = GetNextChild(item, cookie);
1292         }
1293     }
1294 }
1295
1296 void wxGenericTreeCtrl::Collapse(const wxTreeItemId& itemId)
1297 {
1298     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1299
1300     if ( !item->IsExpanded() )
1301         return;
1302
1303     wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_COLLAPSING, GetId() );
1304     event.m_item = (long) item;
1305     event.SetEventObject( this );
1306     if ( ProcessEvent( event ) && !event.IsAllowed() )
1307     {
1308         // cancelled by program
1309         return;
1310     }
1311
1312     item->Collapse();
1313
1314     wxArrayGenericTreeItems& children = item->GetChildren();
1315     size_t count = children.Count();
1316     for ( size_t n = 0; n < count; n++ )
1317     {
1318         Collapse(children[n]);
1319     }
1320
1321     CalculatePositions();
1322
1323     RefreshSubtree(item);
1324
1325     event.SetEventType(wxEVT_COMMAND_TREE_ITEM_COLLAPSED);
1326     ProcessEvent( event );
1327 }
1328
1329 void wxGenericTreeCtrl::CollapseAndReset(const wxTreeItemId& item)
1330 {
1331     Collapse(item);
1332     DeleteChildren(item);
1333 }
1334
1335 void wxGenericTreeCtrl::Toggle(const wxTreeItemId& itemId)
1336 {
1337     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1338
1339     if (item->IsExpanded())
1340         Collapse(itemId);
1341     else
1342         Expand(itemId);
1343 }
1344
1345 void wxGenericTreeCtrl::Unselect()
1346 {
1347     if (m_current)
1348     {
1349         m_current->SetHilight( FALSE );
1350         RefreshLine( m_current );
1351     }
1352 }
1353
1354 void wxGenericTreeCtrl::UnselectAllChildren(wxGenericTreeItem *item)
1355 {
1356     if (item->IsSelected())
1357     {
1358         item->SetHilight(FALSE);
1359         RefreshLine(item);
1360     }
1361
1362     if (item->HasChildren())
1363     {
1364         wxArrayGenericTreeItems& children = item->GetChildren();
1365         size_t count = children.Count();
1366         for ( size_t n = 0; n < count; ++n )
1367         {
1368             UnselectAllChildren(children[n]);
1369         }
1370     }
1371 }
1372
1373 void wxGenericTreeCtrl::UnselectAll()
1374 {
1375     UnselectAllChildren((wxGenericTreeItem*) GetRootItem().m_pItem);
1376 }
1377
1378 // Recursive function !
1379 // To stop we must have crt_item<last_item
1380 // Algorithm :
1381 // Tag all next children, when no more children,
1382 // Move to parent (not to tag)
1383 // Keep going... if we found last_item, we stop.
1384 bool wxGenericTreeCtrl::TagNextChildren(wxGenericTreeItem *crt_item, wxGenericTreeItem *last_item, bool select)
1385 {
1386     wxGenericTreeItem *parent = crt_item->GetParent();
1387
1388     if (parent == NULL) // This is root item
1389         return TagAllChildrenUntilLast(crt_item, last_item, select);
1390
1391     wxArrayGenericTreeItems& children = parent->GetChildren();
1392     int index = children.Index(crt_item);
1393     wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
1394
1395     size_t count = children.Count();
1396     for (size_t n=(size_t)(index+1); n<count; ++n)
1397     {
1398         if (TagAllChildrenUntilLast(children[n], last_item, select)) return TRUE;
1399     }
1400
1401     return TagNextChildren(parent, last_item, select);
1402 }
1403
1404 bool wxGenericTreeCtrl::TagAllChildrenUntilLast(wxGenericTreeItem *crt_item, wxGenericTreeItem *last_item, bool select)
1405 {
1406     crt_item->SetHilight(select);
1407     RefreshLine(crt_item);
1408
1409     if (crt_item==last_item)
1410         return TRUE;
1411
1412     if (crt_item->HasChildren())
1413     {
1414         wxArrayGenericTreeItems& children = crt_item->GetChildren();
1415         size_t count = children.Count();
1416         for ( size_t n = 0; n < count; ++n )
1417         {
1418             if (TagAllChildrenUntilLast(children[n], last_item, select))
1419                 return TRUE;
1420         }
1421     }
1422
1423   return FALSE;
1424 }
1425
1426 void wxGenericTreeCtrl::SelectItemRange(wxGenericTreeItem *item1, wxGenericTreeItem *item2)
1427 {
1428     // item2 is not necessary after item1
1429     wxGenericTreeItem *first=NULL, *last=NULL;
1430
1431     // choice first' and 'last' between item1 and item2
1432     if (item1->GetY()<item2->GetY())
1433     {
1434         first=item1;
1435         last=item2;
1436     }
1437     else
1438     {
1439         first=item2;
1440         last=item1;
1441     }
1442
1443     bool select = m_current->IsSelected();
1444
1445     if ( TagAllChildrenUntilLast(first,last,select) )
1446         return;
1447
1448     TagNextChildren(first,last,select);
1449 }
1450
1451 void wxGenericTreeCtrl::SelectItem(const wxTreeItemId& itemId,
1452                             bool unselect_others,
1453                             bool extended_select)
1454 {
1455     wxCHECK_RET( itemId.IsOk(), wxT("invalid tree item") );
1456
1457     bool is_single=!(GetWindowStyleFlag() & wxTR_MULTIPLE);
1458     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1459
1460     //wxCHECK_RET( ( (!unselect_others) && is_single),
1461     //           wxT("this is a single selection tree") );
1462
1463     // to keep going anyhow !!!
1464     if (is_single)
1465     {
1466         if (item->IsSelected())
1467             return; // nothing to do
1468         unselect_others = TRUE;
1469         extended_select = FALSE;
1470     }
1471     else if ( unselect_others && item->IsSelected() )
1472     {
1473         // selection change if there is more than one item currently selected
1474         wxArrayTreeItemIds selected_items;
1475         if ( GetSelections(selected_items) == 1 )
1476             return;
1477     }
1478
1479     wxTreeEvent event( wxEVT_COMMAND_TREE_SEL_CHANGING, GetId() );
1480     event.m_item = (long) item;
1481     event.m_itemOld = (long) m_current;
1482     event.SetEventObject( this );
1483     // TODO : Here we don't send any selection mode yet !
1484
1485     if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() )
1486       return;
1487
1488     wxTreeItemId parent = GetParent( itemId );
1489     while (parent.IsOk())
1490     {
1491         if (!IsExpanded(parent))
1492             Expand( parent );
1493
1494         parent = GetParent( parent );
1495     }
1496
1497     EnsureVisible( itemId );
1498
1499     // ctrl press
1500     if (unselect_others)
1501     {
1502         if (is_single) Unselect(); // to speed up thing
1503         else UnselectAll();
1504     }
1505
1506     // shift press
1507     if (extended_select)
1508     {
1509         if ( !m_current )
1510         {
1511             m_current =
1512             m_key_current = (wxGenericTreeItem*) GetRootItem().m_pItem;
1513         }
1514
1515         // don't change the mark (m_current)
1516         SelectItemRange(m_current, item);
1517     }
1518     else
1519     {
1520         bool select=TRUE; // the default
1521
1522         // Check if we need to toggle hilight (ctrl mode)
1523         if (!unselect_others)
1524           select=!item->IsSelected();
1525
1526         m_current = m_key_current = item;
1527         m_current->SetHilight(select);
1528         RefreshLine( m_current );
1529     }
1530
1531     event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
1532     GetEventHandler()->ProcessEvent( event );
1533 }
1534
1535 void wxGenericTreeCtrl::FillArray(wxGenericTreeItem *item,
1536                            wxArrayTreeItemIds &array) const
1537 {
1538     if ( item->IsSelected() )
1539         array.Add(wxTreeItemId(item));
1540
1541     if ( item->HasChildren() )
1542     {
1543         wxArrayGenericTreeItems& children = item->GetChildren();
1544         size_t count = children.GetCount();
1545         for ( size_t n = 0; n < count; ++n )
1546             FillArray(children[n], array);
1547     }
1548 }
1549
1550 size_t wxGenericTreeCtrl::GetSelections(wxArrayTreeItemIds &array) const
1551 {
1552   array.Empty();
1553   wxTreeItemId idRoot = GetRootItem();
1554   if ( idRoot.IsOk() )
1555   {
1556       FillArray((wxGenericTreeItem*) idRoot.m_pItem, array);
1557   }
1558   //else: the tree is empty, so no selections
1559
1560   return array.Count();
1561 }
1562
1563 void wxGenericTreeCtrl::EnsureVisible(const wxTreeItemId& item)
1564 {
1565     if (!item.IsOk()) return;
1566
1567     wxGenericTreeItem *gitem = (wxGenericTreeItem*) item.m_pItem;
1568
1569     // first expand all parent branches
1570     wxGenericTreeItem *parent = gitem->GetParent();
1571     while ( parent )
1572     {
1573         Expand(parent);
1574         parent = parent->GetParent();
1575     }
1576
1577     //if (parent) CalculatePositions();
1578
1579     ScrollTo(item);
1580 }
1581
1582 void wxGenericTreeCtrl::ScrollTo(const wxTreeItemId &item)
1583 {
1584     if (!item.IsOk()) return;
1585
1586     // We have to call this here because the label in
1587     // question might just have been added and no screen
1588     // update taken place.
1589     if (m_dirty) wxYieldIfNeeded();
1590
1591     wxGenericTreeItem *gitem = (wxGenericTreeItem*) item.m_pItem;
1592
1593     // now scroll to the item
1594     int item_y = gitem->GetY();
1595
1596     int start_x = 0;
1597     int start_y = 0;
1598     GetViewStart( &start_x, &start_y );
1599     start_y *= PIXELS_PER_UNIT;
1600
1601     int client_h = 0;
1602     int client_w = 0;
1603     GetClientSize( &client_w, &client_h );
1604
1605     if (item_y < start_y+3)
1606     {
1607         // going down
1608         int x = 0;
1609         int y = 0;
1610         m_anchor->GetSize( x, y, this );
1611         y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1612         x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1613         int x_pos = GetScrollPos( wxHORIZONTAL );
1614         // Item should appear at top
1615         SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, item_y/PIXELS_PER_UNIT );
1616     }
1617     else if (item_y+GetLineHeight(gitem) > start_y+client_h)
1618     {
1619         // going up
1620         int x = 0;
1621         int y = 0;
1622         m_anchor->GetSize( x, y, this );
1623         y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1624         x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1625         item_y += PIXELS_PER_UNIT+2;
1626         int x_pos = GetScrollPos( wxHORIZONTAL );
1627         // Item should appear at bottom
1628         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 );
1629     }
1630 }
1631
1632 // FIXME: tree sorting functions are not reentrant and not MT-safe!
1633 static wxGenericTreeCtrl *s_treeBeingSorted = NULL;
1634
1635 static int LINKAGEMODE tree_ctrl_compare_func(wxGenericTreeItem **item1,
1636                                   wxGenericTreeItem **item2)
1637 {
1638     wxCHECK_MSG( s_treeBeingSorted, 0, wxT("bug in wxGenericTreeCtrl::SortChildren()") );
1639
1640     return s_treeBeingSorted->OnCompareItems(*item1, *item2);
1641 }
1642
1643 int wxGenericTreeCtrl::OnCompareItems(const wxTreeItemId& item1,
1644                                const wxTreeItemId& item2)
1645 {
1646     return wxStrcmp(GetItemText(item1), GetItemText(item2));
1647 }
1648
1649 void wxGenericTreeCtrl::SortChildren(const wxTreeItemId& itemId)
1650 {
1651     wxCHECK_RET( itemId.IsOk(), wxT("invalid tree item") );
1652
1653     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1654
1655     wxCHECK_RET( !s_treeBeingSorted,
1656                  wxT("wxGenericTreeCtrl::SortChildren is not reentrant") );
1657
1658     wxArrayGenericTreeItems& children = item->GetChildren();
1659     if ( children.Count() > 1 )
1660     {
1661         s_treeBeingSorted = this;
1662         children.Sort(tree_ctrl_compare_func);
1663         s_treeBeingSorted = NULL;
1664
1665         m_dirty = TRUE;
1666     }
1667     //else: don't make the tree dirty as nothing changed
1668 }
1669
1670 wxImageList *wxGenericTreeCtrl::GetImageList() const
1671 {
1672     return m_imageListNormal;
1673 }
1674
1675 wxImageList *wxGenericTreeCtrl::GetStateImageList() const
1676 {
1677     return m_imageListState;
1678 }
1679
1680 void wxGenericTreeCtrl::SetImageList(wxImageList *imageList)
1681 {
1682     if (m_ownsImageListNormal) delete m_imageListNormal;
1683
1684     m_imageListNormal = imageList;
1685     m_ownsImageListNormal = FALSE;
1686
1687     if ( !m_imageListNormal )
1688         return;
1689
1690     // Calculate a m_lineHeight value from the image sizes.
1691     // May be toggle off. Then wxGenericTreeCtrl will spread when
1692     // necessary (which might look ugly).
1693     wxClientDC dc(this);
1694     m_lineHeight = (int)(dc.GetCharHeight() + 4);
1695     int width = 0, height = 0,
1696         n = m_imageListNormal->GetImageCount();
1697
1698     for (int i = 0; i < n ; i++)
1699     {
1700         m_imageListNormal->GetSize(i, width, height);
1701         if (height > m_lineHeight) m_lineHeight = height;
1702     }
1703
1704     if (m_lineHeight < 40)
1705         m_lineHeight += 2;                 // at least 2 pixels
1706     else
1707         m_lineHeight += m_lineHeight/10;   // otherwise 10% extra spacing
1708 }
1709
1710 void wxGenericTreeCtrl::SetStateImageList(wxImageList *imageList)
1711 {
1712     if (m_ownsImageListState) delete m_imageListState;
1713     m_imageListState = imageList;
1714     m_ownsImageListState = FALSE;
1715 }
1716
1717 void wxGenericTreeCtrl::AssignImageList(wxImageList *imageList)
1718 {
1719     SetImageList(imageList);
1720     m_ownsImageListNormal = TRUE;
1721 }
1722
1723 void wxGenericTreeCtrl::AssignStateImageList(wxImageList *imageList)
1724 {
1725     SetStateImageList(imageList);
1726     m_ownsImageListState = TRUE;
1727 }
1728
1729 // -----------------------------------------------------------------------------
1730 // helpers
1731 // -----------------------------------------------------------------------------
1732
1733 void wxGenericTreeCtrl::AdjustMyScrollbars()
1734 {
1735     if (m_anchor)
1736     {
1737         int x = 0;
1738         int y = 0;
1739         m_anchor->GetSize( x, y, this );
1740         y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1741         x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1742         int x_pos = GetScrollPos( wxHORIZONTAL );
1743         int y_pos = GetScrollPos( wxVERTICAL );
1744         SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, y_pos );
1745     }
1746     else
1747     {
1748         SetScrollbars( 0, 0, 0, 0 );
1749     }
1750 }
1751
1752 int wxGenericTreeCtrl::GetLineHeight(wxGenericTreeItem *item) const
1753 {
1754     if (GetWindowStyleFlag() & wxTR_HAS_VARIABLE_ROW_HEIGHT)
1755         return item->GetHeight();
1756     else
1757         return m_lineHeight;
1758 }
1759
1760 void wxGenericTreeCtrl::PaintItem(wxGenericTreeItem *item, wxDC& dc)
1761 {
1762     wxTreeItemAttr *attr = item->GetAttributes();
1763     if ( attr && attr->HasFont() )
1764         dc.SetFont(attr->GetFont());
1765     else if (item->IsBold())
1766         dc.SetFont(m_boldFont);
1767
1768     long text_w = 0;
1769     long text_h = 0;
1770     dc.GetTextExtent( item->GetText(), &text_w, &text_h );
1771
1772     int image_h = 0;
1773     int image_w = 0;
1774     int image = item->GetCurrentImage();
1775     if ( image != NO_IMAGE )
1776     {
1777         if ( m_imageListNormal )
1778         {
1779             m_imageListNormal->GetSize( image, image_w, image_h );
1780             image_w += 4;
1781         }
1782         else
1783         {
1784             image = NO_IMAGE;
1785         }
1786     }
1787
1788     int total_h = GetLineHeight(item);
1789
1790     bool paintBg = item->IsSelected() && m_hasFocus;
1791     if ( paintBg )
1792     {
1793         dc.SetBrush(*m_hilightBrush);
1794     }
1795     else
1796     {
1797         wxColour colBg;
1798         if ( attr && attr->HasBackgroundColour() )
1799             colBg = attr->GetBackgroundColour();
1800         else
1801             colBg = m_backgroundColour;
1802         dc.SetBrush(wxBrush(colBg, wxSOLID));
1803     }
1804
1805     int offset = HasFlag(wxTR_ROW_LINES) ? 1 : 0;
1806
1807     if ( item->IsSelected() && image != NO_IMAGE)
1808     {
1809         // If it's selected, and there's an image, then we should
1810         // take care to leave the area under the image painted in the
1811         // background colour.
1812         dc.DrawRectangle( item->GetX() + image_w - 2, item->GetY()+offset,
1813                           item->GetWidth() - image_w + 2, total_h-offset );
1814     }
1815     else
1816     {
1817         dc.DrawRectangle( item->GetX()-2, item->GetY()+offset,
1818                           item->GetWidth()+2, total_h-offset );
1819     }
1820
1821     if ( image != NO_IMAGE )
1822     {
1823         dc.SetClippingRegion( item->GetX(), item->GetY(), image_w-2, total_h );
1824         m_imageListNormal->Draw( image, dc,
1825                                  item->GetX(),
1826                                  item->GetY() +((total_h > image_h)?((total_h-image_h)/2):0),
1827                                  wxIMAGELIST_DRAW_TRANSPARENT );
1828         dc.DestroyClippingRegion();
1829     }
1830
1831     dc.SetBackgroundMode(wxTRANSPARENT);
1832     int extraH = (total_h > text_h) ? (total_h - text_h)/2 : 0;
1833     dc.DrawText( item->GetText(),
1834                  (wxCoord)(image_w + item->GetX()),
1835                  (wxCoord)(item->GetY() + extraH));
1836
1837     // restore normal font
1838     dc.SetFont( m_normalFont );
1839 }
1840
1841 // Now y stands for the top of the item, whereas it used to stand for middle !
1842 void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y )
1843 {
1844     int x = (level+1)*m_indent;
1845
1846     item->SetX( x+m_spacing );
1847     item->SetY( y );
1848
1849     int oldY = y;
1850     y+=GetLineHeight(item)/2;
1851
1852     item->SetCross( x, y );
1853
1854     int exposed_x = dc.LogicalToDeviceX( 0 );
1855     int exposed_y = dc.LogicalToDeviceY( item->GetY() );
1856
1857     bool drawLines = (!HasFlag(wxTR_NO_LINES) && !HasFlag(wxTR_MAC_BUTTONS));
1858
1859     if (IsExposed( exposed_x, exposed_y, 10000, GetLineHeight(item) ))  // 10000 = very much
1860     {
1861         int startX = x - m_indent;
1862         int endX = x-5;
1863
1864         if (!item->HasChildren()) endX += 20;
1865
1866         if (HasFlag( wxTR_MAC_BUTTONS ))
1867         {
1868             if (item->HasPlus())
1869             {
1870                 dc.SetPen( *wxBLACK_PEN );
1871                 dc.SetBrush( *m_hilightBrush );
1872
1873                 wxPoint button[3];
1874
1875                 if (item->IsExpanded())
1876                 {
1877                     button[0].x = x-5;
1878                     button[0].y = y-2;
1879                     button[1].x = x+5;
1880                     button[1].y = y-2;
1881                     button[2].x = x;
1882                     button[2].y = y+3;
1883                 }
1884                 else
1885                 {
1886                     button[0].y = y-5;
1887                     button[0].x = x-2;
1888                     button[1].y = y+5;
1889                     button[1].x = x-2;
1890                     button[2].y = y;
1891                     button[2].x = x+3;
1892                 }
1893                 dc.DrawPolygon( 3, button );
1894
1895                 dc.SetPen( m_dottedPen );
1896             }
1897         }
1898         else
1899         {
1900             if (drawLines)
1901                 dc.DrawLine( startX, y, endX, y );
1902
1903             if (item->HasPlus())
1904             {
1905                 if (drawLines)
1906                     dc.DrawLine( x+5, y, x+15, y );
1907                 dc.SetPen( *wxGREY_PEN );
1908                 dc.SetBrush( *wxWHITE_BRUSH );
1909                 dc.DrawRectangle( x-5, y-4, 11, 9 );
1910
1911                 dc.SetPen( *wxBLACK_PEN );
1912                 dc.DrawLine( x-2, y, x+3, y );
1913                 if (!item->IsExpanded())
1914                     dc.DrawLine( x, y-2, x, y+3 );
1915                 dc.SetPen( m_dottedPen );
1916             }
1917         }
1918
1919         wxPen *pen;
1920 #ifndef __WXMAC__
1921         // don't draw rect outline if we already have the background color
1922         // under Max
1923         if ( item->IsSelected() )
1924             pen = wxBLACK_PEN;
1925         else
1926 #endif // !__WXMAC__
1927             pen = wxTRANSPARENT_PEN;
1928
1929         wxColour colText;
1930         if ( item->IsSelected() && m_hasFocus )
1931         {
1932             colText = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_HIGHLIGHTTEXT );
1933         }
1934         else
1935         {
1936             wxTreeItemAttr *attr = item->GetAttributes();
1937             if ( attr && attr->HasTextColour() )
1938                 colText = attr->GetTextColour();
1939             else
1940                 colText = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_WINDOWTEXT );
1941         }
1942
1943         // prepare to draw
1944         dc.SetTextForeground(colText);
1945         dc.SetPen(*pen);
1946
1947         // draw
1948         PaintItem(item, dc);
1949
1950         if (HasFlag( wxTR_ROW_LINES ))
1951         {
1952             dc.SetPen( *wxWHITE_PEN );
1953             dc.DrawLine( 0, oldY, 10000, oldY );
1954             dc.DrawLine( 0, oldY + GetLineHeight(item), 10000, oldY + GetLineHeight(item) );
1955         }
1956
1957         // restore DC objects
1958         dc.SetBrush( *wxWHITE_BRUSH );
1959         dc.SetPen( m_dottedPen );
1960         dc.SetTextForeground( *wxBLACK );
1961     }
1962
1963     y = oldY+GetLineHeight(item);
1964
1965     if (item->IsExpanded())
1966     {
1967         oldY+=GetLineHeight(item)/2;
1968         int semiOldY=0;
1969
1970         wxArrayGenericTreeItems& children = item->GetChildren();
1971         size_t n, count = children.Count();
1972         for ( n = 0; n < count; ++n )
1973         {
1974             semiOldY=y;
1975             PaintLevel( children[n], dc, level+1, y );
1976         }
1977
1978         // it may happen that the item is expanded but has no items (when you
1979         // delete all its children for example) - don't draw the vertical line
1980         // in this case
1981         if (count > 0)
1982         {
1983             semiOldY+=GetLineHeight(children[--n])/2;
1984             if (drawLines)
1985                 dc.DrawLine( x, oldY+5, x, semiOldY );
1986         }
1987     }
1988 }
1989
1990 void wxGenericTreeCtrl::DrawDropEffect(wxGenericTreeItem *item)
1991 {
1992     if ( item )
1993     {
1994         if ( item->HasPlus() )
1995         {
1996             // it's a folder, indicate it by a border
1997             DrawBorder(item);
1998         }
1999         else
2000         {
2001             // draw a line under the drop target because the item will be
2002             // dropped there
2003             DrawLine(item, TRUE /* below */);
2004         }
2005
2006         SetCursor(wxCURSOR_BULLSEYE);
2007     }
2008     else
2009     {
2010         // can't drop here
2011         SetCursor(wxCURSOR_NO_ENTRY);
2012     }
2013 }
2014
2015 void wxGenericTreeCtrl::DrawBorder(const wxTreeItemId &item)
2016 {
2017     wxCHECK_RET( item.IsOk(), _T("invalid item in wxGenericTreeCtrl::DrawLine") );
2018
2019     wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
2020
2021     wxClientDC dc(this);
2022     PrepareDC( dc );
2023     dc.SetLogicalFunction(wxINVERT);
2024     dc.SetBrush(*wxTRANSPARENT_BRUSH);
2025
2026     int w = i->GetWidth() + 2;
2027     int h = GetLineHeight(i) + 2;
2028
2029     dc.DrawRectangle( i->GetX() - 1, i->GetY() - 1, w, h);
2030 }
2031
2032 void wxGenericTreeCtrl::DrawLine(const wxTreeItemId &item, bool below)
2033 {
2034     wxCHECK_RET( item.IsOk(), _T("invalid item in wxGenericTreeCtrl::DrawLine") );
2035
2036     wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
2037
2038     wxClientDC dc(this);
2039     PrepareDC( dc );
2040     dc.SetLogicalFunction(wxINVERT);
2041
2042     int x = i->GetX(),
2043         y = i->GetY();
2044     if ( below )
2045     {
2046         y += GetLineHeight(i) - 1;
2047     }
2048
2049     dc.DrawLine( x, y, x + i->GetWidth(), y);
2050 }
2051
2052 // -----------------------------------------------------------------------------
2053 // wxWindows callbacks
2054 // -----------------------------------------------------------------------------
2055
2056 void wxGenericTreeCtrl::OnPaint( wxPaintEvent &WXUNUSED(event) )
2057 {
2058     wxPaintDC dc(this);
2059     PrepareDC( dc );
2060
2061     if ( !m_anchor)
2062         return;
2063
2064     dc.SetFont( m_normalFont );
2065     dc.SetPen( m_dottedPen );
2066
2067     // this is now done dynamically
2068     //if(GetImageList() == NULL)
2069     // m_lineHeight = (int)(dc.GetCharHeight() + 4);
2070
2071     int y = 2;
2072     PaintLevel( m_anchor, dc, 0, y );
2073 }
2074
2075 void wxGenericTreeCtrl::OnSetFocus( wxFocusEvent &WXUNUSED(event) )
2076 {
2077     m_hasFocus = TRUE;
2078
2079     if (m_current)
2080         RefreshLine( m_current );
2081 }
2082
2083 void wxGenericTreeCtrl::OnKillFocus( wxFocusEvent &WXUNUSED(event) )
2084 {
2085     m_hasFocus = FALSE;
2086
2087     if (m_current)
2088         RefreshLine( m_current );
2089 }
2090
2091 void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
2092 {
2093     wxTreeEvent te( wxEVT_COMMAND_TREE_KEY_DOWN, GetId() );
2094     te.m_code = (int)event.KeyCode();
2095     te.SetEventObject( this );
2096     GetEventHandler()->ProcessEvent( te );
2097
2098     if ( (m_current == 0) || (m_key_current == 0) )
2099     {
2100         event.Skip();
2101         return;
2102     }
2103
2104     // how should the selection work for this event?
2105     bool is_multiple, extended_select, unselect_others;
2106     EventFlagsToSelType(GetWindowStyleFlag(),
2107                         event.ShiftDown(),
2108                         event.ControlDown(),
2109                         is_multiple, extended_select, unselect_others);
2110
2111     // + : Expand
2112     // - : Collaspe
2113     // * : Expand all/Collapse all
2114     // ' ' | return : activate
2115     // up    : go up (not last children!)
2116     // down  : go down
2117     // left  : go to parent
2118     // right : open if parent and go next
2119     // home  : go to root
2120     // end   : go to last item without opening parents
2121     switch (event.KeyCode())
2122     {
2123         case '+':
2124         case WXK_ADD:
2125             if (m_current->HasPlus() && !IsExpanded(m_current))
2126             {
2127                 Expand(m_current);
2128             }
2129             break;
2130
2131         case '*':
2132         case WXK_MULTIPLY:
2133             if ( !IsExpanded(m_current) )
2134             {
2135                 // expand all
2136                 ExpandAll(m_current);
2137                 break;
2138             }
2139             //else: fall through to Collapse() it
2140
2141         case '-':
2142         case WXK_SUBTRACT:
2143             if (IsExpanded(m_current))
2144             {
2145                 Collapse(m_current);
2146             }
2147             break;
2148
2149         case ' ':
2150         case WXK_RETURN:
2151             {
2152                 wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
2153                 event.m_item = (long) m_current;
2154                 event.m_code = 0;
2155                 event.SetEventObject( this );
2156                 GetEventHandler()->ProcessEvent( event );
2157             }
2158             break;
2159
2160             // up goes to the previous sibling or to the last of its children if
2161             // it's expanded
2162         case WXK_UP:
2163             {
2164                 wxTreeItemId prev = GetPrevSibling( m_key_current );
2165                 if (!prev)
2166                 {
2167                     prev = GetParent( m_key_current );
2168                     if (prev)
2169                     {
2170                         long cockie = 0;
2171                         wxTreeItemId current = m_key_current;
2172                         if (current == GetFirstChild( prev, cockie ))
2173                         {
2174                             // otherwise we return to where we came from
2175                             SelectItem( prev, unselect_others, extended_select );
2176                             m_key_current= (wxGenericTreeItem*) prev.m_pItem;
2177                             EnsureVisible( prev );
2178                             break;
2179                         }
2180                     }
2181                 }
2182                 if (prev)
2183                 {
2184                     while ( IsExpanded(prev) && HasChildren(prev) )
2185                     {
2186                         wxTreeItemId child = GetLastChild(prev);
2187                         if ( child )
2188                         {
2189                             prev = child;
2190                         }
2191                     }
2192
2193                     SelectItem( prev, unselect_others, extended_select );
2194                     m_key_current=(wxGenericTreeItem*) prev.m_pItem;
2195                     EnsureVisible( prev );
2196                 }
2197             }
2198             break;
2199
2200             // left arrow goes to the parent
2201         case WXK_LEFT:
2202             {
2203                 wxTreeItemId prev = GetParent( m_current );
2204                 if (prev)
2205                 {
2206                     EnsureVisible( prev );
2207                     SelectItem( prev, unselect_others, extended_select );
2208                 }
2209             }
2210             break;
2211
2212         case WXK_RIGHT:
2213             // this works the same as the down arrow except that we also expand the
2214             // item if it wasn't expanded yet
2215             Expand(m_current);
2216             // fall through
2217
2218         case WXK_DOWN:
2219             {
2220                 if (IsExpanded(m_key_current) && HasChildren(m_key_current))
2221                 {
2222                     long cookie = 0;
2223                     wxTreeItemId child = GetFirstChild( m_key_current, cookie );
2224                     SelectItem( child, unselect_others, extended_select );
2225                     m_key_current=(wxGenericTreeItem*) child.m_pItem;
2226                     EnsureVisible( child );
2227                 }
2228                 else
2229                 {
2230                     wxTreeItemId next = GetNextSibling( m_key_current );
2231                     if (!next)
2232                     {
2233                         wxTreeItemId current = m_key_current;
2234                         while (current && !next)
2235                         {
2236                             current = GetParent( current );
2237                             if (current) next = GetNextSibling( current );
2238                         }
2239                     }
2240                     if (next)
2241                     {
2242                         SelectItem( next, unselect_others, extended_select );
2243                         m_key_current=(wxGenericTreeItem*) next.m_pItem;
2244                         EnsureVisible( next );
2245                     }
2246                 }
2247             }
2248             break;
2249
2250             // <End> selects the last visible tree item
2251         case WXK_END:
2252             {
2253                 wxTreeItemId last = GetRootItem();
2254
2255                 while ( last.IsOk() && IsExpanded(last) )
2256                 {
2257                     wxTreeItemId lastChild = GetLastChild(last);
2258
2259                     // it may happen if the item was expanded but then all of
2260                     // its children have been deleted - so IsExpanded() returned
2261                     // TRUE, but GetLastChild() returned invalid item
2262                     if ( !lastChild )
2263                         break;
2264
2265                     last = lastChild;
2266                 }
2267
2268                 if ( last.IsOk() )
2269                 {
2270                     EnsureVisible( last );
2271                     SelectItem( last, unselect_others, extended_select );
2272                 }
2273             }
2274             break;
2275
2276             // <Home> selects the root item
2277         case WXK_HOME:
2278             {
2279                 wxTreeItemId prev = GetRootItem();
2280                 if (prev)
2281                 {
2282                     EnsureVisible( prev );
2283                     SelectItem( prev, unselect_others, extended_select );
2284                 }
2285             }
2286             break;
2287
2288         default:
2289             event.Skip();
2290     }
2291 }
2292
2293 wxTreeItemId wxGenericTreeCtrl::HitTest(const wxPoint& point, int& flags)
2294 {
2295     // We have to call this here because the label in
2296     // question might just have been added and no screen
2297     // update taken place.
2298     // JACS: removed this because the yield can cause the window to be
2299     // deleted from under us if a close window event is pending
2300     // if (m_dirty) wxYieldIfNeeded();
2301
2302     wxClientDC dc(this);
2303     PrepareDC(dc);
2304     wxCoord x = dc.DeviceToLogicalX( point.x );
2305     wxCoord y = dc.DeviceToLogicalY( point.y );
2306     int w, h;
2307     GetSize(&w, &h);
2308
2309     flags=0;
2310     if (point.x<0) flags|=wxTREE_HITTEST_TOLEFT;
2311     if (point.x>w) flags|=wxTREE_HITTEST_TORIGHT;
2312     if (point.y<0) flags|=wxTREE_HITTEST_ABOVE;
2313     if (point.y>h) flags|=wxTREE_HITTEST_BELOW;
2314
2315     if (m_anchor)
2316         return m_anchor->HitTest( wxPoint(x, y), this, flags);
2317
2318     return wxTreeItemId();
2319 }
2320
2321 // get the bounding rectangle of the item (or of its label only)
2322 bool wxGenericTreeCtrl::GetBoundingRect(const wxTreeItemId& item,
2323                          wxRect& rect,
2324                          bool WXUNUSED(textOnly)) const
2325 {
2326     wxCHECK_MSG( item.IsOk(), FALSE, _T("invalid item in wxGenericTreeCtrl::GetBoundingRect") );
2327
2328     wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
2329
2330     int startX, startY;
2331     GetViewStart(& startX, & startY);
2332
2333     rect.x = i->GetX() - startX*PIXELS_PER_UNIT;
2334     rect.y = i->GetY() - startY*PIXELS_PER_UNIT;
2335     rect.width = i->GetWidth();
2336     //rect.height = i->GetHeight();
2337     rect.height = GetLineHeight(i);
2338
2339     return TRUE;
2340 }
2341
2342 /* **** */
2343
2344 void wxGenericTreeCtrl::Edit( const wxTreeItemId& item )
2345 {
2346     if (!item.IsOk()) return;
2347
2348     m_currentEdit = (wxGenericTreeItem*) item.m_pItem;
2349
2350     wxTreeEvent te( wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, GetId() );
2351     te.m_item = (long) m_currentEdit;
2352     te.SetEventObject( this );
2353     GetEventHandler()->ProcessEvent( te );
2354
2355     if (!te.IsAllowed()) return;
2356
2357     // We have to call this here because the label in
2358     // question might just have been added and no screen
2359     // update taken place.
2360     if (m_dirty) wxYieldIfNeeded();
2361
2362     wxString s = m_currentEdit->GetText();
2363     int x = m_currentEdit->GetX();
2364     int y = m_currentEdit->GetY();
2365     int w = m_currentEdit->GetWidth();
2366     int h = m_currentEdit->GetHeight();
2367
2368     int image_h = 0;
2369     int image_w = 0;
2370
2371     int image = m_currentEdit->GetCurrentImage();
2372     if ( image != NO_IMAGE )
2373     {
2374         if ( m_imageListNormal )
2375         {
2376             m_imageListNormal->GetSize( image, image_w, image_h );
2377             image_w += 4;
2378         }
2379         else
2380         {
2381             wxFAIL_MSG(_T("you must create an image list to use images!"));
2382         }
2383     }
2384     x += image_w;
2385     w -= image_w + 4; // I don't know why +4 is needed
2386
2387     wxClientDC dc(this);
2388     PrepareDC( dc );
2389     x = dc.LogicalToDeviceX( x );
2390     y = dc.LogicalToDeviceY( y );
2391
2392     wxTreeTextCtrl *text = new wxTreeTextCtrl(this, -1,
2393                                               &m_renameAccept,
2394                                               &m_renameRes,
2395                                               this,
2396                                               s,
2397                                               wxPoint(x-4,y-4),
2398                                               wxSize(w+11,h+8));
2399     text->SetFocus();
2400 }
2401
2402 void wxGenericTreeCtrl::OnRenameTimer()
2403 {
2404     Edit( m_current );
2405 }
2406
2407 void wxGenericTreeCtrl::OnRenameAccept()
2408 {
2409     wxTreeEvent le( wxEVT_COMMAND_TREE_END_LABEL_EDIT, GetId() );
2410     le.m_item = (long) m_currentEdit;
2411     le.SetEventObject( this );
2412     le.m_label = m_renameRes;
2413     GetEventHandler()->ProcessEvent( le );
2414
2415     if (!le.IsAllowed()) return;
2416
2417     SetItemText( m_currentEdit, m_renameRes );
2418 }
2419
2420 void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
2421 {
2422     if ( !m_anchor ) return;
2423
2424     // we process left mouse up event (enables in-place edit), right down
2425     // (pass to the user code), left dbl click (activate item) and
2426     // dragging/moving events for items drag-and-drop
2427     if ( !(event.LeftDown() ||
2428            event.LeftUp() ||
2429            event.RightDown() ||
2430            event.LeftDClick() ||
2431            event.Dragging() ||
2432            ((event.Moving() || event.RightUp()) && m_isDragging)) )
2433     {
2434         event.Skip();
2435
2436         return;
2437     }
2438
2439     wxClientDC dc(this);
2440     PrepareDC(dc);
2441     wxCoord x = dc.DeviceToLogicalX( event.GetX() );
2442     wxCoord y = dc.DeviceToLogicalY( event.GetY() );
2443
2444     int flags = 0;
2445     wxGenericTreeItem *item = m_anchor->HitTest( wxPoint(x,y), this, flags);
2446
2447     if ( event.Dragging() && !m_isDragging )
2448     {
2449         if (m_dragCount == 0)
2450             m_dragStart = wxPoint(x,y);
2451
2452         m_dragCount++;
2453
2454         if (m_dragCount != 3)
2455         {
2456             // wait until user drags a bit further...
2457             return;
2458         }
2459
2460         wxEventType command = event.RightIsDown()
2461                               ? wxEVT_COMMAND_TREE_BEGIN_RDRAG
2462                               : wxEVT_COMMAND_TREE_BEGIN_DRAG;
2463
2464         wxTreeEvent nevent( command, GetId() );
2465         nevent.m_item = (long) m_current;
2466         nevent.SetEventObject(this);
2467
2468         // by default the dragging is not supported, the user code must
2469         // explicitly allow the event for it to take place
2470         nevent.Veto();
2471
2472         if ( GetEventHandler()->ProcessEvent(nevent) && nevent.IsAllowed() )
2473         {
2474             // we're going to drag this item
2475             m_isDragging = TRUE;
2476
2477             // remember the old cursor because we will change it while
2478             // dragging
2479             m_oldCursor = m_cursor;
2480
2481             // in a single selection control, hide the selection temporarily
2482             if ( !(GetWindowStyleFlag() & wxTR_MULTIPLE) )
2483             {
2484                 m_oldSelection = (wxGenericTreeItem*) GetSelection().m_pItem;
2485
2486                 if ( m_oldSelection )
2487                 {
2488                     m_oldSelection->SetHilight(FALSE);
2489                     RefreshLine(m_oldSelection);
2490                 }
2491             }
2492
2493             CaptureMouse();
2494         }
2495     }
2496     else if ( event.Moving() )
2497     {
2498         if ( item != m_dropTarget )
2499         {
2500             // unhighlight the previous drop target
2501             DrawDropEffect(m_dropTarget);
2502
2503             m_dropTarget = item;
2504
2505             // highlight the current drop target if any
2506             DrawDropEffect(m_dropTarget);
2507
2508             wxYieldIfNeeded();
2509         }
2510     }
2511     else if ( (event.LeftUp() || event.RightUp()) && m_isDragging )
2512     {
2513         // erase the highlighting
2514         DrawDropEffect(m_dropTarget);
2515
2516         if ( m_oldSelection )
2517         {
2518             m_oldSelection->SetHilight(TRUE);
2519             RefreshLine(m_oldSelection);
2520             m_oldSelection = (wxGenericTreeItem *)NULL;
2521         }
2522
2523         // generate the drag end event
2524         wxTreeEvent event(wxEVT_COMMAND_TREE_END_DRAG, GetId());
2525
2526         event.m_item = (long) item;
2527         event.m_pointDrag = wxPoint(x, y);
2528         event.SetEventObject(this);
2529
2530         (void)GetEventHandler()->ProcessEvent(event);
2531
2532         m_isDragging = FALSE;
2533         m_dropTarget = (wxGenericTreeItem *)NULL;
2534
2535         ReleaseMouse();
2536
2537         SetCursor(m_oldCursor);
2538
2539         wxYieldIfNeeded();
2540     }
2541     else
2542     {
2543         // here we process only the messages which happen on tree items
2544
2545         m_dragCount = 0;
2546
2547         if (item == NULL) return;  /* we hit the blank area */
2548
2549         if ( event.RightDown() )
2550         {
2551             wxTreeEvent nevent(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK, GetId());
2552             nevent.m_item = (long) item;
2553             nevent.m_code = 0;
2554             CalcScrolledPosition(x, y,
2555                                  &nevent.m_pointDrag.x,
2556                                  &nevent.m_pointDrag.y);
2557             nevent.SetEventObject(this);
2558             GetEventHandler()->ProcessEvent(nevent);
2559         }
2560         else if ( event.LeftUp() )
2561         {
2562             if ( m_lastOnSame )
2563             {
2564                 if ( (item == m_current) &&
2565                      (flags & wxTREE_HITTEST_ONITEMLABEL) &&
2566                      HasFlag(wxTR_EDIT_LABELS) )
2567                 {
2568                     if ( m_renameTimer->IsRunning() )
2569                         m_renameTimer->Stop();
2570
2571                     m_renameTimer->Start( 100, TRUE );
2572                 }
2573
2574                 m_lastOnSame = FALSE;
2575             }
2576         }
2577         else // !RightDown() && !LeftUp() ==> LeftDown() || LeftDClick()
2578         {
2579             if ( event.LeftDown() )
2580             {
2581                 m_lastOnSame = item == m_current;
2582             }
2583
2584             if ( flags & wxTREE_HITTEST_ONITEMBUTTON )
2585             {
2586                 // only toggle the item for a single click, double click on
2587                 // the button doesn't do anything (it toggles the item twice)
2588                 if ( event.LeftDown() )
2589                 {
2590                     Toggle( item );
2591                 }
2592
2593                 // don't select the item if the button was clicked
2594                 return;
2595             }
2596
2597             // how should the selection work for this event?
2598             bool is_multiple, extended_select, unselect_others;
2599             EventFlagsToSelType(GetWindowStyleFlag(),
2600                                 event.ShiftDown(),
2601                                 event.ControlDown(),
2602                                 is_multiple, extended_select, unselect_others);
2603
2604             SelectItem(item, unselect_others, extended_select);
2605
2606             if ( event.LeftDClick() )
2607             {
2608                 // double clicking should not start editing the item label
2609                 m_renameTimer->Stop();
2610                 m_lastOnSame = FALSE;
2611
2612                 wxTreeEvent nevent( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
2613                 nevent.m_item = (long) item;
2614                 nevent.m_code = 0;
2615                 CalcScrolledPosition(x, y,
2616                                      &nevent.m_pointDrag.x,
2617                                      &nevent.m_pointDrag.y);
2618                 nevent.SetEventObject( this );
2619                 GetEventHandler()->ProcessEvent( nevent );
2620             }
2621         }
2622     }
2623 }
2624
2625 void wxGenericTreeCtrl::OnIdle( wxIdleEvent &WXUNUSED(event) )
2626 {
2627     /* after all changes have been done to the tree control,
2628      * we actually redraw the tree when everything is over */
2629
2630     if (!m_dirty)
2631         return;
2632
2633     m_dirty = FALSE;
2634
2635     CalculatePositions();
2636     Refresh();
2637     AdjustMyScrollbars();
2638 }
2639
2640 void wxGenericTreeCtrl::CalculateSize( wxGenericTreeItem *item, wxDC &dc )
2641 {
2642     wxCoord text_w = 0;
2643     wxCoord text_h = 0;
2644
2645     if (item->IsBold())
2646         dc.SetFont(m_boldFont);
2647
2648     dc.GetTextExtent( item->GetText(), &text_w, &text_h );
2649     text_h+=2;
2650
2651     // restore normal font
2652     dc.SetFont( m_normalFont );
2653
2654     int image_h = 0;
2655     int image_w = 0;
2656     int image = item->GetCurrentImage();
2657     if ( image != NO_IMAGE )
2658     {
2659         if ( m_imageListNormal )
2660         {
2661             m_imageListNormal->GetSize( image, image_w, image_h );
2662             image_w += 4;
2663         }
2664     }
2665
2666     int total_h = (image_h > text_h) ? image_h : text_h;
2667
2668     if (total_h < 40)
2669         total_h += 2;            // at least 2 pixels
2670     else
2671         total_h += total_h/10;   // otherwise 10% extra spacing
2672
2673     item->SetHeight(total_h);
2674     if (total_h>m_lineHeight)
2675         m_lineHeight=total_h;
2676
2677     item->SetWidth(image_w+text_w+2);
2678 }
2679
2680 // -----------------------------------------------------------------------------
2681 // for developper : y is now the top of the level
2682 // not the middle of it !
2683 void wxGenericTreeCtrl::CalculateLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y )
2684 {
2685     int horizX = level*m_indent;
2686
2687     CalculateSize( item, dc );
2688
2689     // set its position
2690     item->SetX( horizX+m_indent+m_spacing );
2691     item->SetY( y );
2692     y+=GetLineHeight(item);
2693
2694     if ( !item->IsExpanded() )
2695     {
2696         // we dont need to calculate collapsed branches
2697         return;
2698     }
2699
2700     wxArrayGenericTreeItems& children = item->GetChildren();
2701     size_t n, count = children.Count();
2702     for (n = 0; n < count; ++n )
2703         CalculateLevel( children[n], dc, level+1, y );  // recurse
2704 }
2705
2706 void wxGenericTreeCtrl::CalculatePositions()
2707 {
2708     if ( !m_anchor ) return;
2709
2710     wxClientDC dc(this);
2711     PrepareDC( dc );
2712
2713     dc.SetFont( m_normalFont );
2714
2715     dc.SetPen( m_dottedPen );
2716     //if(GetImageList() == NULL)
2717     // m_lineHeight = (int)(dc.GetCharHeight() + 4);
2718
2719     int y = 2;
2720     CalculateLevel( m_anchor, dc, 0, y ); // start recursion
2721 }
2722
2723 void wxGenericTreeCtrl::RefreshSubtree(wxGenericTreeItem *item)
2724 {
2725     if (m_dirty) return;
2726
2727     wxClientDC dc(this);
2728     PrepareDC(dc);
2729
2730     int cw = 0;
2731     int ch = 0;
2732     GetClientSize( &cw, &ch );
2733
2734     wxRect rect;
2735     rect.x = dc.LogicalToDeviceX( 0 );
2736     rect.width = cw;
2737     rect.y = dc.LogicalToDeviceY( item->GetY() );
2738     rect.height = ch;
2739
2740     Refresh( TRUE, &rect );
2741
2742     AdjustMyScrollbars();
2743 }
2744
2745 void wxGenericTreeCtrl::RefreshLine( wxGenericTreeItem *item )
2746 {
2747     if (m_dirty) return;
2748
2749     wxClientDC dc(this);
2750     PrepareDC( dc );
2751
2752     int cw = 0;
2753     int ch = 0;
2754     GetClientSize( &cw, &ch );
2755
2756     wxRect rect;
2757     rect.x = dc.LogicalToDeviceX( 0 );
2758     rect.y = dc.LogicalToDeviceY( item->GetY() );
2759     rect.width = cw;
2760     rect.height = GetLineHeight(item); //dc.GetCharHeight() + 6;
2761
2762     Refresh( TRUE, &rect );
2763 }
2764
2765 #endif // wxUSE_TREECTRL