src/generic/treectrl.cpp

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