src/generic/treectlg.cpp

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