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     wxGenericTreeItem *parent = item->GetParent();
1076
1077     if ( parent )
1078     {
1079         parent->GetChildren().Remove( item );  // remove by value
1080     }
1081
1082     item->DeleteChildren(this);
1083     SendDeleteEvent(item);
1084     delete item;
1085
1086     m_dirty = TRUE;
1087 }
1088
1089 void wxTreeCtrl::DeleteAllItems()
1090 {
1091     if ( m_anchor )
1092     {
1093         m_anchor->DeleteChildren(this);
1094         delete m_anchor;
1095
1096         m_anchor = NULL;
1097
1098         m_dirty = TRUE;
1099     }
1100 }
1101
1102 void wxTreeCtrl::Expand(const wxTreeItemId& itemId)
1103 {
1104     wxGenericTreeItem *item = itemId.m_pItem;
1105
1106     if ( !item->HasPlus() )
1107         return;
1108
1109     if ( item->IsExpanded() )
1110         return;
1111
1112     wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_EXPANDING, GetId() );
1113     event.m_item = item;
1114     event.SetEventObject( this );
1115
1116 //  if ( ProcessEvent( event ) && event.m_code )  TODO: Was this a typo ?
1117     if ( ProcessEvent( event ) && !event.IsAllowed() )
1118     {
1119         // cancelled by program
1120         return;
1121     }
1122
1123     item->Expand();
1124     CalculatePositions();
1125
1126     RefreshSubtree(item);
1127
1128     event.SetEventType(wxEVT_COMMAND_TREE_ITEM_EXPANDED);
1129     ProcessEvent( event );
1130 }
1131
1132 void wxTreeCtrl::Collapse(const wxTreeItemId& itemId)
1133 {
1134     wxGenericTreeItem *item = itemId.m_pItem;
1135
1136     if ( !item->IsExpanded() )
1137         return;
1138
1139     wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_COLLAPSING, GetId() );
1140     event.m_item = item;
1141     event.SetEventObject( this );
1142     if ( ProcessEvent( event ) && !event.IsAllowed() )
1143     {
1144         // cancelled by program
1145         return;
1146     }
1147
1148     item->Collapse();
1149
1150     wxArrayGenericTreeItems& children = item->GetChildren();
1151     size_t count = children.Count();
1152     for ( size_t n = 0; n < count; n++ )
1153     {
1154         Collapse(children[n]);
1155     }
1156
1157     CalculatePositions();
1158
1159     RefreshSubtree(item);
1160
1161     event.SetEventType(wxEVT_COMMAND_TREE_ITEM_COLLAPSED);
1162     ProcessEvent( event );
1163 }
1164
1165 void wxTreeCtrl::CollapseAndReset(const wxTreeItemId& item)
1166 {
1167     Collapse(item);
1168     DeleteChildren(item);
1169 }
1170
1171 void wxTreeCtrl::Toggle(const wxTreeItemId& itemId)
1172 {
1173     wxGenericTreeItem *item = itemId.m_pItem;
1174
1175     if (item->IsExpanded())
1176         Collapse(itemId);
1177     else
1178         Expand(itemId);
1179 }
1180
1181 void wxTreeCtrl::Unselect()
1182 {
1183     if (m_current)
1184     {
1185         m_current->SetHilight( FALSE );
1186         RefreshLine( m_current );
1187     }
1188 }
1189
1190 void wxTreeCtrl::UnselectAllChildren(wxGenericTreeItem *item)
1191 {
1192     if (item->IsSelected())
1193     {
1194         item->SetHilight(FALSE);
1195         RefreshLine(item);
1196     }
1197
1198     if (item->HasChildren())
1199     {
1200         wxArrayGenericTreeItems& children = item->GetChildren();
1201         size_t count = children.Count();
1202         for ( size_t n = 0; n < count; ++n )
1203         {
1204             UnselectAllChildren(children[n]);
1205         }
1206     }
1207 }
1208
1209 void wxTreeCtrl::UnselectAll()
1210 {
1211     UnselectAllChildren(GetRootItem().m_pItem);
1212 }
1213
1214 // Recursive function !
1215 // To stop we must have crt_item<last_item
1216 // Algorithm :
1217 // Tag all next children, when no more children,
1218 // Move to parent (not to tag)
1219 // Keep going... if we found last_item, we stop.
1220 bool wxTreeCtrl::TagNextChildren(wxGenericTreeItem *crt_item, wxGenericTreeItem *last_item, bool select)
1221 {
1222     wxGenericTreeItem *parent = crt_item->GetParent();
1223
1224     if (parent == NULL) // This is root item
1225         return TagAllChildrenUntilLast(crt_item, last_item, select);
1226
1227     wxArrayGenericTreeItems& children = parent->GetChildren();
1228     int index = children.Index(crt_item);
1229     wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
1230
1231     size_t count = children.Count();
1232     for (size_t n=(size_t)(index+1); n<count; ++n)
1233     {
1234         if (TagAllChildrenUntilLast(children[n], last_item, select)) return TRUE;
1235     }
1236
1237     return TagNextChildren(parent, last_item, select);
1238 }
1239
1240 bool wxTreeCtrl::TagAllChildrenUntilLast(wxGenericTreeItem *crt_item, wxGenericTreeItem *last_item, bool select)
1241 {
1242     crt_item->SetHilight(select);
1243     RefreshLine(crt_item);
1244
1245     if (crt_item==last_item)
1246         return TRUE;
1247
1248     if (crt_item->HasChildren())
1249     {
1250         wxArrayGenericTreeItems& children = crt_item->GetChildren();
1251         size_t count = children.Count();
1252         for ( size_t n = 0; n < count; ++n )
1253         {
1254             if (TagAllChildrenUntilLast(children[n], last_item, select))
1255                 return TRUE;
1256         }
1257     }
1258
1259   return FALSE;
1260 }
1261
1262 void wxTreeCtrl::SelectItemRange(wxGenericTreeItem *item1, wxGenericTreeItem *item2)
1263 {
1264     // item2 is not necessary after item1
1265     wxGenericTreeItem *first=NULL, *last=NULL;
1266
1267     // choice first' and 'last' between item1 and item2
1268     if (item1->GetY()<item2->GetY())
1269     {
1270         first=item1;
1271         last=item2;
1272     }
1273     else
1274     {
1275         first=item2;
1276         last=item1;
1277     }
1278
1279     bool select = m_current->IsSelected();
1280
1281     if ( TagAllChildrenUntilLast(first,last,select) )
1282         return;
1283
1284     TagNextChildren(first,last,select);
1285 }
1286
1287 void wxTreeCtrl::SelectItem(const wxTreeItemId& itemId,
1288                             bool unselect_others,
1289                             bool extended_select)
1290 {
1291     wxCHECK_RET( itemId.IsOk(), wxT("invalid tree item") );
1292
1293     bool is_single=!(GetWindowStyleFlag() & wxTR_MULTIPLE);
1294     wxGenericTreeItem *item = itemId.m_pItem;
1295
1296     //wxCHECK_RET( ( (!unselect_others) && is_single),
1297     //           wxT("this is a single selection tree") );
1298
1299     // to keep going anyhow !!!
1300     if (is_single)
1301     {
1302         if (item->IsSelected())
1303             return; // nothing to do
1304         unselect_others = TRUE;
1305         extended_select = FALSE;
1306     }
1307     else if ( unselect_others && item->IsSelected() )
1308     {
1309         // selection change if there is more than one item currently selected
1310         wxArrayTreeItemIds selected_items;
1311         if ( GetSelections(selected_items) == 1 )
1312             return;
1313     }
1314
1315     wxTreeEvent event( wxEVT_COMMAND_TREE_SEL_CHANGING, GetId() );
1316     event.m_item = item;
1317     event.m_itemOld = m_current;
1318     event.SetEventObject( this );
1319     // TODO : Here we don't send any selection mode yet !
1320
1321     if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() )
1322       return;
1323
1324     // ctrl press
1325     if (unselect_others)
1326     {
1327         if (is_single) Unselect(); // to speed up thing
1328         else UnselectAll();
1329     }
1330
1331     // shift press
1332     if (extended_select)
1333     {
1334         if (m_current == NULL) m_current=m_key_current=GetRootItem().m_pItem;
1335         // don't change the mark (m_current)
1336         SelectItemRange(m_current, item);
1337     }
1338     else
1339     {
1340         bool select=TRUE; // the default
1341
1342         // Check if we need to toggle hilight (ctrl mode)
1343         if (!unselect_others)
1344           select=!item->IsSelected();
1345
1346         m_current = m_key_current = item;
1347         m_current->SetHilight(select);
1348         RefreshLine( m_current );
1349     }
1350
1351     event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
1352     GetEventHandler()->ProcessEvent( event );
1353 }
1354
1355 void wxTreeCtrl::FillArray(wxGenericTreeItem *item,
1356                            wxArrayTreeItemIds &array) const
1357 {
1358     if ( item->IsSelected() )
1359         array.Add(wxTreeItemId(item));
1360
1361     if ( item->HasChildren() )
1362     {
1363         wxArrayGenericTreeItems& children = item->GetChildren();
1364         size_t count = children.GetCount();
1365         for ( size_t n = 0; n < count; ++n )
1366             FillArray(children[n],array);
1367     }
1368 }
1369
1370 size_t wxTreeCtrl::GetSelections(wxArrayTreeItemIds &array) const
1371 {
1372   array.Empty();
1373   FillArray(GetRootItem().m_pItem, array);
1374
1375   return array.Count();
1376 }
1377
1378 void wxTreeCtrl::EnsureVisible(const wxTreeItemId& item)
1379 {
1380     if (!item.IsOk()) return;
1381
1382     wxGenericTreeItem *gitem = item.m_pItem;
1383
1384     // first expand all parent branches
1385     wxGenericTreeItem *parent = gitem->GetParent();
1386     while ( parent )
1387     {
1388         Expand(parent);
1389         parent = parent->GetParent();
1390     }
1391
1392     //if (parent) CalculatePositions();
1393
1394     ScrollTo(item);
1395 }
1396
1397 void wxTreeCtrl::ScrollTo(const wxTreeItemId &item)
1398 {
1399     if (!item.IsOk()) return;
1400
1401     // We have to call this here because the label in
1402     // question might just have been added and no screen
1403     // update taken place.
1404     if (m_dirty) wxYield();
1405
1406     wxGenericTreeItem *gitem = item.m_pItem;
1407
1408     // now scroll to the item
1409     int item_y = gitem->GetY();
1410
1411     int start_x = 0;
1412     int start_y = 0;
1413     ViewStart( &start_x, &start_y );
1414     start_y *= PIXELS_PER_UNIT;
1415
1416     int client_h = 0;
1417     int client_w = 0;
1418     GetClientSize( &client_w, &client_h );
1419
1420     if (item_y < start_y+3)
1421     {
1422         // going down
1423         int x = 0;
1424         int y = 0;
1425         m_anchor->GetSize( x, y, this );
1426         y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1427         x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1428         int x_pos = GetScrollPos( wxHORIZONTAL );
1429         // Item should appear at top
1430         SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, item_y/PIXELS_PER_UNIT );
1431     }
1432     else if (item_y+GetLineHeight(gitem) > start_y+client_h)
1433     {
1434         // going up
1435         int x = 0;
1436         int y = 0;
1437         m_anchor->GetSize( x, y, this );
1438         y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1439         x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1440         item_y += PIXELS_PER_UNIT+2;
1441         int x_pos = GetScrollPos( wxHORIZONTAL );
1442         // Item should appear at bottom
1443         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 );
1444     }
1445 }
1446
1447 // FIXME: tree sorting functions are not reentrant and not MT-safe!
1448 static wxTreeCtrl *s_treeBeingSorted = NULL;
1449
1450 static int LINKAGEMODE tree_ctrl_compare_func(wxGenericTreeItem **item1,
1451                                   wxGenericTreeItem **item2)
1452 {
1453     wxCHECK_MSG( s_treeBeingSorted, 0, wxT("bug in wxTreeCtrl::SortChildren()") );
1454
1455     return s_treeBeingSorted->OnCompareItems(*item1, *item2);
1456 }
1457
1458 int wxTreeCtrl::OnCompareItems(const wxTreeItemId& item1,
1459                                const wxTreeItemId& item2)
1460 {
1461     return wxStrcmp(GetItemText(item1), GetItemText(item2));
1462 }
1463
1464 void wxTreeCtrl::SortChildren(const wxTreeItemId& itemId)
1465 {
1466     wxCHECK_RET( itemId.IsOk(), wxT("invalid tree item") );
1467
1468     wxGenericTreeItem *item = itemId.m_pItem;
1469
1470     wxCHECK_RET( !s_treeBeingSorted,
1471                  wxT("wxTreeCtrl::SortChildren is not reentrant") );
1472
1473     wxArrayGenericTreeItems& children = item->GetChildren();
1474     if ( children.Count() > 1 )
1475     {
1476         s_treeBeingSorted = this;
1477         children.Sort(tree_ctrl_compare_func);
1478         s_treeBeingSorted = NULL;
1479
1480         m_dirty = TRUE;
1481     }
1482     //else: don't make the tree dirty as nothing changed
1483 }
1484
1485 wxImageList *wxTreeCtrl::GetImageList() const
1486 {
1487     return m_imageListNormal;
1488 }
1489
1490 wxImageList *wxTreeCtrl::GetStateImageList() const
1491 {
1492     return m_imageListState;
1493 }
1494
1495 void wxTreeCtrl::SetImageList(wxImageList *imageList)
1496 {
1497     m_imageListNormal = imageList;
1498
1499     // Calculate a m_lineHeight value from the image sizes.
1500     // May be toggle off. Then wxTreeCtrl will spread when
1501     // necessary (which might look ugly).
1502 #if 1
1503     wxClientDC dc(this);
1504     m_lineHeight = (int)(dc.GetCharHeight() + 4);
1505     int width = 0, height = 0,
1506         n = m_imageListNormal->GetImageCount();
1507
1508     for (int i = 0; i < n ; i++)
1509     {
1510         m_imageListNormal->GetSize(i, width, height);
1511         if (height > m_lineHeight) m_lineHeight = height;
1512     }
1513
1514     if (m_lineHeight < 40)
1515         m_lineHeight += 2;                 // at least 2 pixels
1516     else
1517         m_lineHeight += m_lineHeight/10;   // otherwise 10% extra spacing
1518 #endif
1519 }
1520
1521 void wxTreeCtrl::SetStateImageList(wxImageList *imageList)
1522 {
1523     m_imageListState = imageList;
1524 }
1525
1526 // -----------------------------------------------------------------------------
1527 // helpers
1528 // -----------------------------------------------------------------------------
1529
1530 void wxTreeCtrl::AdjustMyScrollbars()
1531 {
1532     if (m_anchor)
1533     {
1534         int x = 0;
1535         int y = 0;
1536         m_anchor->GetSize( x, y, this );
1537         y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1538         x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1539         int x_pos = GetScrollPos( wxHORIZONTAL );
1540         int y_pos = GetScrollPos( wxVERTICAL );
1541         SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, y_pos );
1542     }
1543     else
1544     {
1545         SetScrollbars( 0, 0, 0, 0 );
1546     }
1547 }
1548
1549 int wxTreeCtrl::GetLineHeight(wxGenericTreeItem *item) const
1550 {
1551     if (GetWindowStyleFlag() & wxTR_HAS_VARIABLE_ROW_HEIGHT)
1552         return item->GetHeight();
1553     else
1554         return m_lineHeight;
1555 }
1556
1557 void wxTreeCtrl::PaintItem(wxGenericTreeItem *item, wxDC& dc)
1558 {
1559     wxTreeItemAttr *attr = item->GetAttributes();
1560     if ( attr && attr->HasFont() )
1561         dc.SetFont(attr->GetFont());
1562     else if (item->IsBold())
1563         dc.SetFont(m_boldFont);
1564
1565     long text_w = 0;
1566     long text_h = 0;
1567     dc.GetTextExtent( item->GetText(), &text_w, &text_h );
1568
1569     int image_h = 0;
1570     int image_w = 0;
1571     int image = item->GetCurrentImage();
1572     if ( image != NO_IMAGE )
1573     {
1574         m_imageListNormal->GetSize( image, image_w, image_h );
1575         image_w += 4;
1576     }
1577
1578     int total_h = GetLineHeight(item);
1579
1580     if (item->IsSelected())
1581         dc.SetBrush(*m_hilightBrush);
1582     else
1583     {
1584         wxColour colBg;
1585         if ( attr && attr->HasBackgroundColour() )
1586             colBg = attr->GetBackgroundColour();
1587         else
1588             colBg = m_backgroundColour;
1589         dc.SetBrush(wxBrush(colBg, wxSOLID));
1590     }
1591
1592     dc.DrawRectangle( item->GetX()-2, item->GetY(), item->GetWidth()+2, total_h );
1593
1594     if ( image != NO_IMAGE )
1595     {
1596         dc.SetClippingRegion( item->GetX(), item->GetY(), image_w-2, total_h );
1597         m_imageListNormal->Draw( image, dc,
1598                                  item->GetX(),
1599                                  item->GetY() +((total_h > image_h)?((total_h-image_h)/2):0),
1600                                  wxIMAGELIST_DRAW_TRANSPARENT );
1601         dc.DestroyClippingRegion();
1602     }
1603
1604     dc.SetBackgroundMode(wxTRANSPARENT);
1605     dc.DrawText( item->GetText(), image_w + item->GetX(), (wxCoord)item->GetY()
1606                  + ((total_h > text_h) ? (total_h - text_h)/2 : 0));
1607
1608     // restore normal font
1609     dc.SetFont( m_normalFont );
1610 }
1611
1612 // Now y stands for the top of the item, whereas it used to stand for middle !
1613 void wxTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y )
1614 {
1615     int horizX = level*m_indent;
1616
1617     item->SetX( horizX+m_indent+m_spacing );
1618     item->SetY( y );
1619
1620     int oldY = y;
1621     y+=GetLineHeight(item)/2;
1622
1623     item->SetCross( horizX+m_indent, y );
1624
1625     int exposed_x = dc.LogicalToDeviceX( 0 );
1626     int exposed_y = dc.LogicalToDeviceY( item->GetY() );
1627
1628     if (IsExposed( exposed_x, exposed_y, 10000, GetLineHeight(item) ))  // 10000 = very much
1629     {
1630         int startX = horizX;
1631         int endX = horizX + (m_indent-5);
1632
1633 //        if (!item->HasChildren()) endX += (m_indent+5);
1634         if (!item->HasChildren()) endX += 20;
1635
1636         dc.DrawLine( startX, y, endX, y );
1637
1638         if (item->HasPlus())
1639         {
1640             dc.DrawLine( horizX+(m_indent+5), y, horizX+(m_indent+15), y );
1641             dc.SetPen( *wxGREY_PEN );
1642             dc.SetBrush( *wxWHITE_BRUSH );
1643             dc.DrawRectangle( horizX+(m_indent-5), y-4, 11, 9 );
1644
1645             dc.SetPen( *wxBLACK_PEN );
1646             dc.DrawLine( horizX+(m_indent-2), y, horizX+(m_indent+3), y );
1647             if (!item->IsExpanded())
1648                 dc.DrawLine( horizX+m_indent, y-2, horizX+m_indent, y+3 );
1649
1650             dc.SetPen( m_dottedPen );
1651         }
1652
1653         wxPen *pen = wxTRANSPARENT_PEN;
1654         wxColour colText;
1655
1656         if ( item->IsSelected() )
1657         {
1658             colText = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_HIGHLIGHTTEXT );
1659
1660             if ( m_hasFocus )
1661                pen = wxBLACK_PEN;
1662
1663         }
1664         else
1665         {
1666             wxTreeItemAttr *attr = item->GetAttributes();
1667             if ( attr && attr->HasTextColour() )
1668                 colText = attr->GetTextColour();
1669             else
1670                 colText = *wxBLACK;
1671         }
1672
1673         // prepare to draw
1674         dc.SetTextForeground(colText);
1675         dc.SetPen(*pen);
1676
1677         // draw
1678         PaintItem(item, dc);
1679
1680         // restore DC objects
1681         dc.SetBrush( *wxWHITE_BRUSH );
1682         dc.SetPen( m_dottedPen );
1683         dc.SetTextForeground( *wxBLACK );
1684     }
1685
1686     y = oldY+GetLineHeight(item);
1687
1688     if (item->IsExpanded())
1689     {
1690         oldY+=GetLineHeight(item)/2;
1691         int semiOldY=0;
1692
1693         wxArrayGenericTreeItems& children = item->GetChildren();
1694         size_t n, count = children.Count();
1695         for ( n = 0; n < count; ++n )
1696         {
1697             semiOldY=y;
1698             PaintLevel( children[n], dc, level+1, y );
1699         }
1700
1701         // it may happen that the item is expanded but has no items (when you
1702         // delete all its children for example) - don't draw the vertical line
1703         // in this case
1704         if (count > 0)
1705         {
1706             semiOldY+=GetLineHeight(children[--n])/2;
1707             dc.DrawLine( horizX+m_indent, oldY+5, horizX+m_indent, semiOldY );
1708         }
1709     }
1710 }
1711
1712 void wxTreeCtrl::DrawDropEffect(wxGenericTreeItem *item)
1713 {
1714     if ( item )
1715     {
1716         if ( item->HasPlus() )
1717         {
1718             // it's a folder, indicate it by a border
1719             DrawBorder(item);
1720         }
1721         else
1722         {
1723             // draw a line under the drop target because the item will be
1724             // dropped there
1725             DrawLine(item, TRUE /* below */);
1726         }
1727
1728         SetCursor(wxCURSOR_BULLSEYE);
1729     }
1730     else
1731     {
1732         // can't drop here
1733         SetCursor(wxCURSOR_NO_ENTRY);
1734     }
1735 }
1736
1737 void wxTreeCtrl::DrawBorder(const wxTreeItemId &item)
1738 {
1739     wxCHECK_RET( item.IsOk(), _T("invalid item in wxTreeCtrl::DrawLine") );
1740
1741     wxGenericTreeItem *i = item.m_pItem;
1742
1743     wxClientDC dc(this);
1744     PrepareDC( dc );
1745     dc.SetLogicalFunction(wxINVERT);
1746     dc.SetBrush(*wxTRANSPARENT_BRUSH);
1747
1748     int w = i->GetWidth() + 2;
1749     int h = GetLineHeight(i) + 2;
1750
1751     dc.DrawRectangle( i->GetX() - 1, i->GetY() - 1, w, h);
1752 }
1753
1754 void wxTreeCtrl::DrawLine(const wxTreeItemId &item, bool below)
1755 {
1756     wxCHECK_RET( item.IsOk(), _T("invalid item in wxTreeCtrl::DrawLine") );
1757
1758     wxGenericTreeItem *i = item.m_pItem;
1759
1760     wxClientDC dc(this);
1761     PrepareDC( dc );
1762     dc.SetLogicalFunction(wxINVERT);
1763
1764     int x = i->GetX(),
1765         y = i->GetY();
1766     if ( below )
1767     {
1768         y += GetLineHeight(i) - 1;
1769     }
1770
1771     dc.DrawLine( x, y, x + i->GetWidth(), y);
1772 }
1773
1774 // -----------------------------------------------------------------------------
1775 // wxWindows callbacks
1776 // -----------------------------------------------------------------------------
1777
1778 void wxTreeCtrl::OnPaint( wxPaintEvent &WXUNUSED(event) )
1779 {
1780     if ( !m_anchor)
1781         return;
1782
1783     wxPaintDC dc(this);
1784     PrepareDC( dc );
1785
1786     dc.SetFont( m_normalFont );
1787     dc.SetPen( m_dottedPen );
1788
1789     // this is now done dynamically
1790     //if(GetImageList() == NULL)
1791     // m_lineHeight = (int)(dc.GetCharHeight() + 4);
1792
1793     int y = 2;
1794     PaintLevel( m_anchor, dc, 0, y );
1795 }
1796
1797 void wxTreeCtrl::OnSetFocus( wxFocusEvent &WXUNUSED(event) )
1798 {
1799     m_hasFocus = TRUE;
1800
1801     if (m_current) RefreshLine( m_current );
1802 }
1803
1804 void wxTreeCtrl::OnKillFocus( wxFocusEvent &WXUNUSED(event) )
1805 {
1806     m_hasFocus = FALSE;
1807
1808     if (m_current) RefreshLine( m_current );
1809 }
1810
1811 void wxTreeCtrl::OnChar( wxKeyEvent &event )
1812 {
1813     wxTreeEvent te( wxEVT_COMMAND_TREE_KEY_DOWN, GetId() );
1814     te.m_code = (int)event.KeyCode();
1815     te.SetEventObject( this );
1816     GetEventHandler()->ProcessEvent( te );
1817
1818     if ( (m_current == 0) || (m_key_current == 0) )
1819     {
1820         event.Skip();
1821         return;
1822     }
1823
1824     // how should the selection work for this event?
1825     bool is_multiple, extended_select, unselect_others;
1826     EventFlagsToSelType(GetWindowStyleFlag(),
1827                         event.ShiftDown(),
1828                         event.ControlDown(),
1829                         &is_multiple, &extended_select, &unselect_others);
1830
1831     switch (event.KeyCode())
1832     {
1833         case '+':
1834         case WXK_ADD:
1835             if (m_current->HasPlus() && !IsExpanded(m_current))
1836             {
1837                 Expand(m_current);
1838             }
1839             break;
1840
1841         case '-':
1842         case WXK_SUBTRACT:
1843             if (IsExpanded(m_current))
1844             {
1845                 Collapse(m_current);
1846             }
1847             break;
1848
1849         case '*':
1850         case WXK_MULTIPLY:
1851             Toggle(m_current);
1852             break;
1853
1854         case ' ':
1855         case WXK_RETURN:
1856             {
1857                 wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
1858                 event.m_item = m_current;
1859                 event.m_code = 0;
1860                 event.SetEventObject( this );
1861                 GetEventHandler()->ProcessEvent( event );
1862             }
1863             break;
1864
1865             // up goes to the previous sibling or to the last of its children if
1866             // it's expanded
1867         case WXK_UP:
1868             {
1869                 wxTreeItemId prev = GetPrevSibling( m_key_current );
1870                 if (!prev)
1871                 {
1872                     prev = GetParent( m_key_current );
1873                     if (prev)
1874                     {
1875                         long cockie = 0;
1876                         wxTreeItemId current = m_key_current;
1877                         if (current == GetFirstChild( prev, cockie ))
1878                         {
1879                             // otherwise we return to where we came from
1880                             SelectItem( prev, unselect_others, extended_select );
1881                             m_key_current=prev.m_pItem;
1882                             EnsureVisible( prev );
1883                             break;
1884                         }
1885                     }
1886                 }
1887                 if (prev)
1888                 {
1889                     while ( IsExpanded(prev) && HasChildren(prev) )
1890                     {
1891                         wxTreeItemId child = GetLastChild(prev);
1892                         if ( child )
1893                         {
1894                             prev = child;
1895                         }
1896                     }
1897
1898                     SelectItem( prev, unselect_others, extended_select );
1899                     m_key_current=prev.m_pItem;
1900                     EnsureVisible( prev );
1901                 }
1902             }
1903             break;
1904
1905             // left arrow goes to the parent
1906         case WXK_LEFT:
1907             {
1908                 wxTreeItemId prev = GetParent( m_current );
1909                 if (prev)
1910                 {
1911                     EnsureVisible( prev );
1912                     SelectItem( prev, unselect_others, extended_select );
1913                 }
1914             }
1915             break;
1916
1917         case WXK_RIGHT:
1918             // this works the same as the down arrow except that we also expand the
1919             // item if it wasn't expanded yet
1920             Expand(m_current);
1921             // fall through
1922
1923         case WXK_DOWN:
1924             {
1925                 if (IsExpanded(m_key_current) && HasChildren(m_key_current))
1926                 {
1927                     long cookie = 0;
1928                     wxTreeItemId child = GetFirstChild( m_key_current, cookie );
1929                     SelectItem( child, unselect_others, extended_select );
1930                     m_key_current=child.m_pItem;
1931                     EnsureVisible( child );
1932                 }
1933                 else
1934                 {
1935                     wxTreeItemId next = GetNextSibling( m_key_current );
1936 //                    if (next == 0)
1937                     if (!next)
1938                     {
1939                         wxTreeItemId current = m_key_current;
1940                         while (current && !next)
1941                         {
1942                             current = GetParent( current );
1943                             if (current) next = GetNextSibling( current );
1944                         }
1945                     }
1946 //                    if (next != 0)
1947                     if (next)
1948                     {
1949                         SelectItem( next, unselect_others, extended_select );
1950                         m_key_current=next.m_pItem;
1951                         EnsureVisible( next );
1952                     }
1953                 }
1954             }
1955             break;
1956
1957             // <End> selects the last visible tree item
1958         case WXK_END:
1959             {
1960                 wxTreeItemId last = GetRootItem();
1961
1962                 while ( last.IsOk() && IsExpanded(last) )
1963                 {
1964                     wxTreeItemId lastChild = GetLastChild(last);
1965
1966                     // it may happen if the item was expanded but then all of
1967                     // its children have been deleted - so IsExpanded() returned
1968                     // TRUE, but GetLastChild() returned invalid item
1969                     if ( !lastChild )
1970                         break;
1971
1972                     last = lastChild;
1973                 }
1974
1975                 if ( last.IsOk() )
1976                 {
1977                     EnsureVisible( last );
1978                     SelectItem( last, unselect_others, extended_select );
1979                 }
1980             }
1981             break;
1982
1983             // <Home> selects the root item
1984         case WXK_HOME:
1985             {
1986                 wxTreeItemId prev = GetRootItem();
1987                 if (prev)
1988                 {
1989                     EnsureVisible( prev );
1990                     SelectItem( prev, unselect_others, extended_select );
1991                 }
1992             }
1993             break;
1994
1995         default:
1996             event.Skip();
1997     }
1998 }
1999
2000 wxTreeItemId wxTreeCtrl::HitTest(const wxPoint& point, int& flags)
2001 {
2002     // We have to call this here because the label in
2003     // question might just have been added and no screen
2004     // update taken place.
2005     if (m_dirty) wxYield();
2006
2007     wxClientDC dc(this);
2008     PrepareDC(dc);
2009     wxCoord x = dc.DeviceToLogicalX( point.x );
2010     wxCoord y = dc.DeviceToLogicalY( point.y );
2011     int w, h;
2012     GetSize(&w, &h);
2013
2014     flags=0;
2015     if (point.x<0) flags|=wxTREE_HITTEST_TOLEFT;
2016     if (point.x>w) flags|=wxTREE_HITTEST_TORIGHT;
2017     if (point.y<0) flags|=wxTREE_HITTEST_ABOVE;
2018     if (point.y>h) flags|=wxTREE_HITTEST_BELOW;
2019
2020     return m_anchor->HitTest( wxPoint(x, y), this, flags);
2021 }
2022
2023 /* **** */
2024
2025 void wxTreeCtrl::Edit( const wxTreeItemId& item )
2026 {
2027     if (!item.IsOk()) return;
2028
2029     m_currentEdit = item.m_pItem;
2030
2031     wxTreeEvent te( wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, GetId() );
2032     te.m_item = m_currentEdit;
2033     te.SetEventObject( this );
2034     GetEventHandler()->ProcessEvent( te );
2035
2036     if (!te.IsAllowed()) return;
2037
2038     // We have to call this here because the label in
2039     // question might just have been added and no screen
2040     // update taken place.
2041     if (m_dirty) wxYield();
2042
2043     wxString s = m_currentEdit->GetText();
2044     int x = m_currentEdit->GetX();
2045     int y = m_currentEdit->GetY();
2046     int w = m_currentEdit->GetWidth();
2047     int h = m_currentEdit->GetHeight();
2048
2049     int image_h = 0;
2050     int image_w = 0;
2051
2052     int image = m_currentEdit->GetCurrentImage();
2053     if ( image != NO_IMAGE )
2054     {
2055         m_imageListNormal->GetSize( image, image_w, image_h );
2056         image_w += 4;
2057     }
2058     x += image_w;
2059     w -= image_w + 4; // I don't know why +4 is needed
2060
2061     wxClientDC dc(this);
2062     PrepareDC( dc );
2063     x = dc.LogicalToDeviceX( x );
2064     y = dc.LogicalToDeviceY( y );
2065
2066     wxTreeTextCtrl *text = new wxTreeTextCtrl(
2067       this, -1, &m_renameAccept, &m_renameRes, this, s, wxPoint(x-4,y-4), wxSize(w+11,h+8) );
2068     text->SetFocus();
2069 }
2070
2071 void wxTreeCtrl::OnRenameTimer()
2072 {
2073     Edit( m_current );
2074 }
2075
2076 void wxTreeCtrl::OnRenameAccept()
2077 {
2078     wxTreeEvent le( wxEVT_COMMAND_TREE_END_LABEL_EDIT, GetId() );
2079     le.m_item = m_currentEdit;
2080     le.SetEventObject( this );
2081     le.m_label = m_renameRes;
2082     GetEventHandler()->ProcessEvent( le );
2083
2084     if (!le.IsAllowed()) return;
2085
2086     SetItemText( m_currentEdit, m_renameRes );
2087 }
2088
2089 void wxTreeCtrl::OnMouse( wxMouseEvent &event )
2090 {
2091     if ( !m_anchor ) return;
2092
2093     // we process left mouse up event (enables in-place edit), right down
2094     // (pass to the user code), left dbl click (activate item) and
2095     // dragging/moving events for items drag-and-drop
2096     if ( !(event.LeftUp() ||
2097            event.RightDown() ||
2098            event.LeftDClick() ||
2099            event.Dragging() ||
2100            ((event.Moving() || event.RightUp()) && m_isDragging)) )
2101     {
2102         event.Skip();
2103
2104         return;
2105     }
2106
2107     wxClientDC dc(this);
2108     PrepareDC(dc);
2109     wxCoord x = dc.DeviceToLogicalX( event.GetX() );
2110     wxCoord y = dc.DeviceToLogicalY( event.GetY() );
2111
2112     int flags = 0;
2113     wxGenericTreeItem *item = m_anchor->HitTest( wxPoint(x,y), this, flags);
2114
2115     bool onButton = flags & wxTREE_HITTEST_ONITEMBUTTON;
2116
2117     if ( event.Dragging() && !m_isDragging )
2118     {
2119         if (m_dragCount == 0)
2120             m_dragStart = wxPoint(x,y);
2121
2122         m_dragCount++;
2123
2124         if (m_dragCount != 3)
2125         {
2126             // wait until user drags a bit further...
2127             return;
2128         }
2129
2130         wxEventType command = event.RightIsDown()
2131                               ? wxEVT_COMMAND_TREE_BEGIN_RDRAG
2132                               : wxEVT_COMMAND_TREE_BEGIN_DRAG;
2133
2134         wxTreeEvent nevent( command, GetId() );
2135         nevent.m_item = m_current;
2136         nevent.SetEventObject(this);
2137
2138         // by default the dragging is not supported, the user code must
2139         // explicitly allow the event for it to take place
2140         nevent.Veto();
2141
2142         if ( GetEventHandler()->ProcessEvent(nevent) && nevent.IsAllowed() )
2143         {
2144             // we're going to drag this item
2145             m_isDragging = TRUE;
2146
2147             // remember the old cursor because we will change it while
2148             // dragging
2149             m_oldCursor = m_cursor;
2150
2151             // in a single selection control, hide the selection temporarily
2152             if ( !(GetWindowStyleFlag() & wxTR_MULTIPLE) )
2153             {
2154                 m_oldSelection = GetSelection().m_pItem;
2155
2156                 if ( m_oldSelection )
2157                 {
2158                     m_oldSelection->SetHilight(FALSE);
2159                     RefreshLine(m_oldSelection);
2160                 }
2161             }
2162
2163             CaptureMouse();
2164         }
2165     }
2166     else if ( event.Moving() )
2167     {
2168         if ( item != m_dropTarget )
2169         {
2170             // unhighlight the previous drop target
2171             DrawDropEffect(m_dropTarget);
2172
2173             m_dropTarget = item;
2174
2175             // highlight the current drop target if any
2176             DrawDropEffect(m_dropTarget);
2177
2178             wxYield();
2179         }
2180     }
2181     else if ( (event.LeftUp() || event.RightUp()) && m_isDragging )
2182     {
2183         // erase the highlighting
2184         DrawDropEffect(m_dropTarget);
2185
2186         // generate the drag end event
2187         wxTreeEvent event(wxEVT_COMMAND_TREE_END_DRAG, GetId());
2188
2189         event.m_item = item;
2190         event.m_pointDrag = wxPoint(x, y);
2191         event.SetEventObject(this);
2192
2193         (void)GetEventHandler()->ProcessEvent(event);
2194
2195         m_isDragging = FALSE;
2196         m_dropTarget = (wxGenericTreeItem *)NULL;
2197
2198         if ( m_oldSelection )
2199         {
2200             m_oldSelection->SetHilight(TRUE);
2201             RefreshLine(m_oldSelection);
2202             m_oldSelection = (wxGenericTreeItem *)NULL;
2203         }
2204
2205         ReleaseMouse();
2206
2207         SetCursor(m_oldCursor);
2208
2209         wxYield();
2210     }
2211     else
2212     {
2213         // here we process only the messages which happen on tree items
2214
2215         m_dragCount = 0;
2216
2217         if (item == NULL) return;  /* we hit the blank area */
2218
2219         if ( event.RightDown() )
2220         {
2221             wxTreeEvent nevent(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK, GetId());
2222             nevent.m_item = item;
2223             nevent.m_code = 0;
2224             nevent.SetEventObject(this);
2225             GetEventHandler()->ProcessEvent(nevent);
2226         }
2227         else if ( event.LeftUp() && (item == m_current) &&
2228                  (flags & wxTREE_HITTEST_ONITEMLABEL) &&
2229                  HasFlag(wxTR_EDIT_LABELS) )
2230         {
2231             m_renameTimer->Start( 100, TRUE );
2232         }
2233         else
2234         {
2235             // how should the selection work for this event?
2236             bool is_multiple, extended_select, unselect_others;
2237             EventFlagsToSelType(GetWindowStyleFlag(),
2238                                 event.ShiftDown(),
2239                                 event.ControlDown(),
2240                                 &is_multiple, &extended_select, &unselect_others);
2241
2242             if ( onButton )
2243             {
2244                 Toggle( item );
2245                 if ( is_multiple )
2246                     return;
2247             }
2248
2249             SelectItem(item, unselect_others, extended_select);
2250
2251             if ( event.LeftDClick() )
2252             {
2253                 wxTreeEvent nevent( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
2254                 nevent.m_item = item;
2255                 nevent.m_code = 0;
2256                 nevent.SetEventObject( this );
2257                 GetEventHandler()->ProcessEvent( nevent );
2258             }
2259         }
2260     }
2261 }
2262
2263 void wxTreeCtrl::OnIdle( wxIdleEvent &WXUNUSED(event) )
2264 {
2265     /* after all changes have been done to the tree control,
2266      * we actually redraw the tree when everything is over */
2267
2268     if (!m_dirty)
2269         return;
2270
2271     m_dirty = FALSE;
2272
2273     CalculatePositions();
2274     Refresh();
2275     AdjustMyScrollbars();
2276 }
2277
2278 void wxTreeCtrl::CalculateSize( wxGenericTreeItem *item, wxDC &dc )
2279 {
2280     int text_w = 0;
2281     int text_h = 0;
2282
2283     if (item->IsBold())
2284         dc.SetFont(m_boldFont);
2285
2286     dc.GetTextExtent( item->GetText(), &text_w, &text_h );
2287     text_h+=2;
2288
2289     // restore normal font
2290     dc.SetFont( m_normalFont );
2291
2292     int image_h = 0;
2293     int image_w = 0;
2294     int image = item->GetCurrentImage();
2295     if ( image != NO_IMAGE )
2296     {
2297         m_imageListNormal->GetSize( image, image_w, image_h );
2298         image_w += 4;
2299     }
2300
2301     int total_h = (image_h > text_h) ? image_h : text_h;
2302
2303     if (total_h < 40)
2304         total_h += 2;            // at least 2 pixels
2305     else
2306         total_h += total_h/10;   // otherwise 10% extra spacing
2307
2308     item->SetHeight(total_h);
2309     if (total_h>m_lineHeight)
2310         m_lineHeight=total_h;
2311
2312     item->SetWidth(image_w+text_w+2);
2313 }
2314
2315 // -----------------------------------------------------------------------------
2316 // for developper : y is now the top of the level
2317 // not the middle of it !
2318 void wxTreeCtrl::CalculateLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y )
2319 {
2320     int horizX = level*m_indent;
2321
2322     CalculateSize( item, dc );
2323
2324     // set its position
2325     item->SetX( horizX+m_indent+m_spacing );
2326     item->SetY( y );
2327     y+=GetLineHeight(item);
2328
2329     if ( !item->IsExpanded() )
2330     {
2331         // we dont need to calculate collapsed branches
2332         return;
2333     }
2334
2335     wxArrayGenericTreeItems& children = item->GetChildren();
2336     size_t n, count = children.Count();
2337     for (n = 0; n < count; ++n )
2338         CalculateLevel( children[n], dc, level+1, y );  // recurse
2339 }
2340
2341 void wxTreeCtrl::CalculatePositions()
2342 {
2343     if ( !m_anchor ) return;
2344
2345     wxClientDC dc(this);
2346     PrepareDC( dc );
2347
2348     dc.SetFont( m_normalFont );
2349
2350     dc.SetPen( m_dottedPen );
2351     //if(GetImageList() == NULL)
2352     // m_lineHeight = (int)(dc.GetCharHeight() + 4);
2353
2354     int y = 2;
2355     CalculateLevel( m_anchor, dc, 0, y ); // start recursion
2356 }
2357
2358 void wxTreeCtrl::RefreshSubtree(wxGenericTreeItem *item)
2359 {
2360     if (m_dirty) return;
2361
2362     wxClientDC dc(this);
2363     PrepareDC(dc);
2364
2365     int cw = 0;
2366     int ch = 0;
2367     GetClientSize( &cw, &ch );
2368
2369     wxRect rect;
2370     rect.x = dc.LogicalToDeviceX( 0 );
2371     rect.width = cw;
2372     rect.y = dc.LogicalToDeviceY( item->GetY() );
2373     rect.height = ch;
2374
2375     Refresh( TRUE, &rect );
2376
2377     AdjustMyScrollbars();
2378 }
2379
2380 void wxTreeCtrl::RefreshLine( wxGenericTreeItem *item )
2381 {
2382     if (m_dirty) return;
2383
2384     wxClientDC dc(this);
2385     PrepareDC( dc );
2386
2387     int cw = 0;
2388     int ch = 0;
2389     GetClientSize( &cw, &ch );
2390
2391     wxRect rect;
2392     rect.x = dc.LogicalToDeviceX( 0 );
2393     rect.y = dc.LogicalToDeviceY( item->GetY() );
2394     rect.width = cw;
2395     rect.height = GetLineHeight(item); //dc.GetCharHeight() + 6;
2396
2397     Refresh( TRUE, &rect );
2398 }
2399