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 ( item->IsSelected() && image != NO_IMAGE )
1887     {
1888         // If it's selected, and there's an image, then we should
1889         // take care to leave the area under the image painted in the
1890         // background colour.
1891         dc.DrawRectangle( item->GetX() + image_w - 2, item->GetY()+offset,
1892                           item->GetWidth() - image_w + 2, total_h-offset );
1893     }
1894     else
1895     {
1896         dc.DrawRectangle( item->GetX()-2, item->GetY()+offset,
1897                           item->GetWidth()+2, total_h-offset );
1898     }
1899
1900     if ( image != NO_IMAGE )
1901     {
1902         dc.SetClippingRegion( item->GetX(), item->GetY(), image_w-2, total_h );
1903         m_imageListNormal->Draw( image, dc,
1904                                  item->GetX(),
1905                                  item->GetY() +((total_h > image_h)?((total_h-image_h)/2):0),
1906                                  wxIMAGELIST_DRAW_TRANSPARENT );
1907         dc.DestroyClippingRegion();
1908     }
1909
1910     dc.SetBackgroundMode(wxTRANSPARENT);
1911     int extraH = (total_h > text_h) ? (total_h - text_h)/2 : 0;
1912     dc.DrawText( item->GetText(),
1913                  (wxCoord)(image_w + item->GetX()),
1914                  (wxCoord)(item->GetY() + extraH));
1915
1916     // restore normal font
1917     dc.SetFont( m_normalFont );
1918 }
1919
1920 // Now y stands for the top of the item, whereas it used to stand for middle !
1921 void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y )
1922 {
1923     int x = level*m_indent;
1924     if (!HasFlag(wxTR_HIDE_ROOT))
1925     {
1926         x += m_indent;
1927     }
1928     else if (level == 0)
1929     {
1930         // always expand hidden root
1931         int origY = y;
1932         wxArrayGenericTreeItems& children = item->GetChildren();
1933         int count = children.Count();
1934         if (count > 0)
1935         {
1936             int n = 0, oldY;
1937             do {
1938                 oldY = y;
1939                 PaintLevel(children[n], dc, 1, y);
1940             } while (++n < count);
1941
1942             if (!HasFlag(wxTR_NO_LINES) && HasFlag(wxTR_LINES_AT_ROOT) && count > 0)
1943             {
1944                 // draw line down to last child
1945                 origY += GetLineHeight(children[0])>>1;
1946                 oldY += GetLineHeight(children[n-1])>>1;
1947                 dc.DrawLine(3, origY, 3, oldY);
1948             }
1949         }
1950         return;
1951     }
1952
1953     item->SetX(x+m_spacing);
1954     item->SetY(y);
1955
1956     int h = GetLineHeight(item);
1957     int y_top = y;
1958     int y_mid = y_top + (h>>1);
1959     y += h;
1960
1961     int exposed_x = dc.LogicalToDeviceX(0);
1962     int exposed_y = dc.LogicalToDeviceY(y_top);
1963
1964     if (IsExposed(exposed_x, exposed_y, 10000, h))  // 10000 = very much
1965     {
1966         if (item->HasPlus() && HasButtons())  // should the item show a button?
1967         {
1968             if (!HasFlag(wxTR_NO_LINES))
1969             {
1970                 if (x > (signed)m_indent)
1971                     dc.DrawLine(x - m_indent, y_mid, x - 5, y_mid);
1972                 else if (HasFlag(wxTR_LINES_AT_ROOT))
1973                     dc.DrawLine(3, y_mid, x - 5, y_mid);
1974                 dc.DrawLine(x + 5, y_mid, x + m_spacing, y_mid);
1975             }
1976
1977             if (m_imageListButtons != NULL)
1978             {
1979                 // draw the image button here
1980                 int image_h = 0, image_w = 0, image = wxTreeItemIcon_Normal;
1981                 if (item->IsExpanded()) image = wxTreeItemIcon_Expanded;
1982                 if (item->IsSelected())
1983                     image += wxTreeItemIcon_Selected - wxTreeItemIcon_Normal;
1984                 m_imageListButtons->GetSize(image, image_w, image_h);
1985                 int xx = x - (image_w>>1);
1986                 int yy = y_mid - (image_h>>1);
1987                 dc.SetClippingRegion(xx, yy, image_w, image_h);
1988                 m_imageListButtons->Draw(image, dc, xx, yy,
1989                                          wxIMAGELIST_DRAW_TRANSPARENT);
1990                 dc.DestroyClippingRegion();
1991             }
1992             else if (HasFlag(wxTR_TWIST_BUTTONS))
1993             {
1994                 // draw the twisty button here
1995
1996                 wxPoint button[3];
1997                 dc.SetBrush(*m_hilightBrush);
1998
1999                 if (HasFlag(wxTR_AQUA_BUTTONS))
2000                 {
2001                     dc.SetPen(*wxTRANSPARENT_PEN);
2002
2003                     if (item->IsExpanded())
2004                     {
2005                         button[0].x = x-6;
2006                         button[0].y = y_mid-2;
2007                         button[1].x = x+6;
2008                         button[1].y = y_mid-2;
2009                         button[2].x = x;
2010                         button[2].y = y_mid+7;
2011                     }
2012                     else
2013                     {
2014                         button[0].y = y_mid-6;
2015                         button[0].x = x-2;
2016                         button[1].y = y_mid+6;
2017                         button[1].x = x-2;
2018                         button[2].y = y_mid;
2019                         button[2].x = x+7;
2020                     }
2021                 }
2022                 else
2023                 {
2024                     dc.SetPen(*wxBLACK_PEN);
2025
2026                     if (item->IsExpanded())
2027                     {
2028                         button[0].x = x-5;
2029                         button[0].y = y_mid-2;
2030                         button[1].x = x+5;
2031                         button[1].y = y_mid-2;
2032                         button[2].x = x;
2033                         button[2].y = y_mid+3;
2034                     }
2035                     else
2036                     {
2037                         button[0].y = y_mid-5;
2038                         button[0].x = x-2;
2039                         button[1].y = y_mid+5;
2040                         button[1].x = x-2;
2041                         button[2].y = y_mid;
2042                         button[2].x = x+3;
2043                     }
2044                 }
2045                 dc.DrawPolygon(3, button);
2046
2047                 dc.SetPen(m_dottedPen);
2048             }
2049             else // if (HasFlag(wxTR_HAS_BUTTONS))
2050             {
2051                 // draw the plus sign here
2052                 dc.SetPen(*wxGREY_PEN);
2053                 dc.SetBrush(*wxWHITE_BRUSH);
2054                 dc.DrawRectangle(x-5, y_mid-4, 11, 9);
2055                 dc.SetPen(*wxBLACK_PEN);
2056                 dc.DrawLine(x-2, y_mid, x+3, y_mid);
2057                 if (!item->IsExpanded())
2058                     dc.DrawLine(x, y_mid-2, x, y_mid+3);
2059                 dc.SetPen(m_dottedPen);
2060             }
2061         }
2062         else if (!HasFlag(wxTR_NO_LINES))  // no button; maybe a line?
2063         {
2064             // draw the horizontal line here
2065             int x_start = x;
2066             if (x > (signed)m_indent)
2067                 x_start -= m_indent;
2068             else if (HasFlag(wxTR_LINES_AT_ROOT))
2069                 x_start = 3;
2070             dc.DrawLine(x_start, y_mid, x + m_spacing, y_mid);
2071         }
2072
2073         wxPen *pen =
2074 #ifndef __WXMAC__
2075             // don't draw rect outline if we already have the
2076             // background color under Mac
2077             (item->IsSelected() && m_hasFocus) ? wxBLACK_PEN :
2078 #endif // !__WXMAC__
2079             wxTRANSPARENT_PEN;
2080
2081         wxColour colText;
2082         if ( item->IsSelected() )
2083         {
2084             colText = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
2085         }
2086         else
2087         {
2088             wxTreeItemAttr *attr = item->GetAttributes();
2089             if (attr && attr->HasTextColour())
2090                 colText = attr->GetTextColour();
2091             else
2092                 colText = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOWTEXT);
2093         }
2094
2095         // prepare to draw
2096         dc.SetTextForeground(colText);
2097         dc.SetPen(*pen);
2098
2099         // draw
2100         PaintItem(item, dc);
2101
2102         if (HasFlag(wxTR_ROW_LINES))
2103         {
2104             // if the background colour is white, choose a
2105             // contrasting color for the lines
2106             dc.SetPen(*((GetBackgroundColour() == *wxWHITE)
2107                          ? wxMEDIUM_GREY_PEN : wxWHITE_PEN));
2108             dc.DrawLine(0, y_top, 10000, y_top);
2109             dc.DrawLine(0, y, 10000, y);
2110         }
2111
2112         // restore DC objects
2113         dc.SetBrush(*wxWHITE_BRUSH);
2114         dc.SetPen(m_dottedPen);
2115         dc.SetTextForeground(*wxBLACK);
2116     }
2117
2118     if (item->IsExpanded())
2119     {
2120         wxArrayGenericTreeItems& children = item->GetChildren();
2121         int count = children.Count();
2122         if (count > 0)
2123         {
2124             int n = 0, oldY;
2125             ++level;
2126             do {
2127                 oldY = y;
2128                 PaintLevel(children[n], dc, level, y);
2129             } while (++n < count);
2130
2131             if (!HasFlag(wxTR_NO_LINES) && count > 0)
2132             {
2133                 // draw line down to last child
2134                 oldY += GetLineHeight(children[n-1])>>1;
2135                 if (HasButtons()) y_mid += 5;
2136                 dc.DrawLine(x, y_mid, x, oldY);
2137             }
2138         }
2139     }
2140 }
2141
2142 void wxGenericTreeCtrl::DrawDropEffect(wxGenericTreeItem *item)
2143 {
2144     if ( item )
2145     {
2146         if ( item->HasPlus() )
2147         {
2148             // it's a folder, indicate it by a border
2149             DrawBorder(item);
2150         }
2151         else
2152         {
2153             // draw a line under the drop target because the item will be
2154             // dropped there
2155             DrawLine(item, TRUE /* below */);
2156         }
2157
2158         SetCursor(wxCURSOR_BULLSEYE);
2159     }
2160     else
2161     {
2162         // can't drop here
2163         SetCursor(wxCURSOR_NO_ENTRY);
2164     }
2165 }
2166
2167 void wxGenericTreeCtrl::DrawBorder(const wxTreeItemId &item)
2168 {
2169     wxCHECK_RET( item.IsOk(), _T("invalid item in wxGenericTreeCtrl::DrawLine") );
2170
2171     wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
2172
2173     wxClientDC dc(this);
2174     PrepareDC( dc );
2175     dc.SetLogicalFunction(wxINVERT);
2176     dc.SetBrush(*wxTRANSPARENT_BRUSH);
2177
2178     int w = i->GetWidth() + 2;
2179     int h = GetLineHeight(i) + 2;
2180
2181     dc.DrawRectangle( i->GetX() - 1, i->GetY() - 1, w, h);
2182 }
2183
2184 void wxGenericTreeCtrl::DrawLine(const wxTreeItemId &item, bool below)
2185 {
2186     wxCHECK_RET( item.IsOk(), _T("invalid item in wxGenericTreeCtrl::DrawLine") );
2187
2188     wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
2189
2190     wxClientDC dc(this);
2191     PrepareDC( dc );
2192     dc.SetLogicalFunction(wxINVERT);
2193
2194     int x = i->GetX(),
2195         y = i->GetY();
2196     if ( below )
2197     {
2198         y += GetLineHeight(i) - 1;
2199     }
2200
2201     dc.DrawLine( x, y, x + i->GetWidth(), y);
2202 }
2203
2204 // -----------------------------------------------------------------------------
2205 // wxWindows callbacks
2206 // -----------------------------------------------------------------------------
2207
2208 void wxGenericTreeCtrl::OnPaint( wxPaintEvent &WXUNUSED(event) )
2209 {
2210     wxPaintDC dc(this);
2211     PrepareDC( dc );
2212
2213     if ( !m_anchor)
2214         return;
2215
2216     dc.SetFont( m_normalFont );
2217     dc.SetPen( m_dottedPen );
2218
2219     // this is now done dynamically
2220     //if(GetImageList() == NULL)
2221     // m_lineHeight = (int)(dc.GetCharHeight() + 4);
2222
2223     int y = 2;
2224     PaintLevel( m_anchor, dc, 0, y );
2225 }
2226
2227 void wxGenericTreeCtrl::OnSetFocus( wxFocusEvent &event )
2228 {
2229     m_hasFocus = TRUE;
2230
2231     RefreshSelected();
2232
2233     event.Skip();
2234 }
2235
2236 void wxGenericTreeCtrl::OnKillFocus( wxFocusEvent &event )
2237 {
2238     m_hasFocus = FALSE;
2239
2240     RefreshSelected();
2241
2242     event.Skip();
2243 }
2244
2245 void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
2246 {
2247     wxTreeEvent te( wxEVT_COMMAND_TREE_KEY_DOWN, GetId() );
2248     te.m_evtKey = event;
2249     te.SetEventObject( this );
2250     if ( GetEventHandler()->ProcessEvent( te ) )
2251     {
2252         // intercepted by the user code
2253         return;
2254     }
2255
2256     if ( (m_current == 0) || (m_key_current == 0) )
2257     {
2258         event.Skip();
2259         return;
2260     }
2261
2262     // how should the selection work for this event?
2263     bool is_multiple, extended_select, unselect_others;
2264     EventFlagsToSelType(GetWindowStyleFlag(),
2265                         event.ShiftDown(),
2266                         event.ControlDown(),
2267                         is_multiple, extended_select, unselect_others);
2268
2269     // + : Expand
2270     // - : Collaspe
2271     // * : Expand all/Collapse all
2272     // ' ' | return : activate
2273     // up    : go up (not last children!)
2274     // down  : go down
2275     // left  : go to parent
2276     // right : open if parent and go next
2277     // home  : go to root
2278     // end   : go to last item without opening parents
2279     switch (event.KeyCode())
2280     {
2281         case '+':
2282         case WXK_ADD:
2283             if (m_current->HasPlus() && !IsExpanded(m_current))
2284             {
2285                 Expand(m_current);
2286             }
2287             break;
2288
2289         case '*':
2290         case WXK_MULTIPLY:
2291             if ( !IsExpanded(m_current) )
2292             {
2293                 // expand all
2294                 ExpandAll(m_current);
2295                 break;
2296             }
2297             //else: fall through to Collapse() it
2298
2299         case '-':
2300         case WXK_SUBTRACT:
2301             if (IsExpanded(m_current))
2302             {
2303                 Collapse(m_current);
2304             }
2305             break;
2306
2307         case ' ':
2308         case WXK_RETURN:
2309             {
2310                 wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
2311                 event.m_item = (long) m_current;
2312                 event.SetEventObject( this );
2313                 GetEventHandler()->ProcessEvent( event );
2314             }
2315             break;
2316
2317             // up goes to the previous sibling or to the last
2318             // of its children if it's expanded
2319         case WXK_UP:
2320             {
2321                 wxTreeItemId prev = GetPrevSibling( m_key_current );
2322                 if (!prev)
2323                 {
2324                     prev = GetParent( m_key_current );
2325                     if ((prev == GetRootItem()) && HasFlag(wxTR_HIDE_ROOT))
2326                     {
2327                         break;  // don't go to root if it is hidden
2328                     }
2329                     if (prev)
2330                     {
2331                         long cookie = 0;
2332                         wxTreeItemId current = m_key_current;
2333                         // TODO: Huh?  If we get here, we'd better be the first child of our parent.  How else could it be?
2334                         if (current == GetFirstChild( prev, cookie ))
2335                         {
2336                             // otherwise we return to where we came from
2337                             SelectItem( prev, unselect_others, extended_select );
2338                             m_key_current= (wxGenericTreeItem*) prev.m_pItem;
2339                             EnsureVisible( prev );
2340                             break;
2341                         }
2342                     }
2343                 }
2344                 if (prev)
2345                 {
2346                     while ( IsExpanded(prev) && HasChildren(prev) )
2347                     {
2348                         wxTreeItemId child = GetLastChild(prev);
2349                         if ( child )
2350                         {
2351                             prev = child;
2352                         }
2353                     }
2354
2355                     SelectItem( prev, unselect_others, extended_select );
2356                     m_key_current=(wxGenericTreeItem*) prev.m_pItem;
2357                     EnsureVisible( prev );
2358                 }
2359             }
2360             break;
2361
2362             // left arrow goes to the parent
2363         case WXK_LEFT:
2364             {
2365                 wxTreeItemId prev = GetParent( m_current );
2366                 if ((prev == GetRootItem()) && HasFlag(wxTR_HIDE_ROOT))
2367                 {
2368                     // don't go to root if it is hidden
2369                     prev = GetPrevSibling( m_current );
2370                 }
2371                 if (prev)
2372                 {
2373                     EnsureVisible( prev );
2374                     SelectItem( prev, unselect_others, extended_select );
2375                 }
2376             }
2377             break;
2378
2379         case WXK_RIGHT:
2380             // this works the same as the down arrow except that we
2381             // also expand the item if it wasn't expanded yet
2382             Expand(m_current);
2383             // fall through
2384
2385         case WXK_DOWN:
2386             {
2387                 if (IsExpanded(m_key_current) && HasChildren(m_key_current))
2388                 {
2389                     long cookie = 0;
2390                     wxTreeItemId child = GetFirstChild( m_key_current, cookie );
2391                     SelectItem( child, unselect_others, extended_select );
2392                     m_key_current=(wxGenericTreeItem*) child.m_pItem;
2393                     EnsureVisible( child );
2394                 }
2395                 else
2396                 {
2397                     wxTreeItemId next = GetNextSibling( m_key_current );
2398                     if (!next)
2399                     {
2400                         wxTreeItemId current = m_key_current;
2401                         while (current && !next)
2402                         {
2403                             current = GetParent( current );
2404                             if (current) next = GetNextSibling( current );
2405                         }
2406                     }
2407                     if (next)
2408                     {
2409                         SelectItem( next, unselect_others, extended_select );
2410                         m_key_current=(wxGenericTreeItem*) next.m_pItem;
2411                         EnsureVisible( next );
2412                     }
2413                 }
2414             }
2415             break;
2416
2417             // <End> selects the last visible tree item
2418         case WXK_END:
2419             {
2420                 wxTreeItemId last = GetRootItem();
2421
2422                 while ( last.IsOk() && IsExpanded(last) )
2423                 {
2424                     wxTreeItemId lastChild = GetLastChild(last);
2425
2426                     // it may happen if the item was expanded but then all of
2427                     // its children have been deleted - so IsExpanded() returned
2428                     // TRUE, but GetLastChild() returned invalid item
2429                     if ( !lastChild )
2430                         break;
2431
2432                     last = lastChild;
2433                 }
2434
2435                 if ( last.IsOk() )
2436                 {
2437                     EnsureVisible( last );
2438                     SelectItem( last, unselect_others, extended_select );
2439                 }
2440             }
2441             break;
2442
2443             // <Home> selects the root item
2444         case WXK_HOME:
2445             {
2446                 wxTreeItemId prev = GetRootItem();
2447                 if (!prev) break;
2448                 if (HasFlag(wxTR_HIDE_ROOT))
2449                 {
2450                     long dummy;
2451                     prev = GetFirstChild(prev, dummy);
2452                     if (!prev) break;
2453                 }
2454                 EnsureVisible( prev );
2455                 SelectItem( prev, unselect_others, extended_select );
2456             }
2457             break;
2458
2459         default:
2460             event.Skip();
2461     }
2462 }
2463
2464 wxTreeItemId wxGenericTreeCtrl::HitTest(const wxPoint& point, int& flags)
2465 {
2466     // JACS: removed wxYieldIfNeeded() because it can cause the window
2467     // to be deleted from under us if a close window event is pending
2468
2469     int w, h;
2470     GetSize(&w, &h);
2471     flags=0;
2472     if (point.x<0) flags |= wxTREE_HITTEST_TOLEFT;
2473     if (point.x>w) flags |= wxTREE_HITTEST_TORIGHT;
2474     if (point.y<0) flags |= wxTREE_HITTEST_ABOVE;
2475     if (point.y>h) flags |= wxTREE_HITTEST_BELOW;
2476     if (flags) return wxTreeItemId();
2477
2478     if (m_anchor == NULL)
2479     {
2480         flags = wxTREE_HITTEST_NOWHERE;
2481         return wxTreeItemId();
2482     }
2483
2484     wxClientDC dc(this);
2485     PrepareDC(dc);
2486     wxCoord x = dc.DeviceToLogicalX( point.x );
2487     wxCoord y = dc.DeviceToLogicalY( point.y );
2488     wxGenericTreeItem *hit =  m_anchor->HitTest(wxPoint(x, y),
2489                                                 this,
2490                                                 flags,
2491                                                 0 );
2492     if (hit == NULL)
2493     {
2494         flags = wxTREE_HITTEST_NOWHERE;
2495         return wxTreeItemId();
2496     }
2497     return hit;
2498 }
2499
2500 // get the bounding rectangle of the item (or of its label only)
2501 bool wxGenericTreeCtrl::GetBoundingRect(const wxTreeItemId& item,
2502                          wxRect& rect,
2503                          bool WXUNUSED(textOnly)) const
2504 {
2505     wxCHECK_MSG( item.IsOk(), FALSE, _T("invalid item in wxGenericTreeCtrl::GetBoundingRect") );
2506
2507     wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
2508
2509     int startX, startY;
2510     GetViewStart(& startX, & startY);
2511
2512     rect.x = i->GetX() - startX*PIXELS_PER_UNIT;
2513     rect.y = i->GetY() - startY*PIXELS_PER_UNIT;
2514     rect.width = i->GetWidth();
2515     //rect.height = i->GetHeight();
2516     rect.height = GetLineHeight(i);
2517
2518     return TRUE;
2519 }
2520
2521 /* **** */
2522
2523 void wxGenericTreeCtrl::Edit( const wxTreeItemId& item )
2524 {
2525     if (!item.IsOk()) return;
2526
2527     m_currentEdit = (wxGenericTreeItem*) item.m_pItem;
2528
2529     wxTreeEvent te( wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, GetId() );
2530     te.m_item = (long) m_currentEdit;
2531     te.SetEventObject( this );
2532     GetEventHandler()->ProcessEvent( te );
2533
2534     if (!te.IsAllowed()) return;
2535
2536     // We have to call this here because the label in
2537     // question might just have been added and no screen
2538     // update taken place.
2539     if (m_dirty) wxYieldIfNeeded();
2540
2541     wxString s = m_currentEdit->GetText();
2542     int x = m_currentEdit->GetX();
2543     int y = m_currentEdit->GetY();
2544     int w = m_currentEdit->GetWidth();
2545     int h = m_currentEdit->GetHeight();
2546
2547     int image_h = 0;
2548     int image_w = 0;
2549
2550     int image = m_currentEdit->GetCurrentImage();
2551     if ( image != NO_IMAGE )
2552     {
2553         if ( m_imageListNormal )
2554         {
2555             m_imageListNormal->GetSize( image, image_w, image_h );
2556             image_w += 4;
2557         }
2558         else
2559         {
2560             wxFAIL_MSG(_T("you must create an image list to use images!"));
2561         }
2562     }
2563     x += image_w;
2564     w -= image_w + 4; // I don't know why +4 is needed
2565
2566     wxClientDC dc(this);
2567     PrepareDC( dc );
2568     x = dc.LogicalToDeviceX( x );
2569     y = dc.LogicalToDeviceY( y );
2570
2571     wxTreeTextCtrl *text = new wxTreeTextCtrl(this, -1,
2572                                               &m_renameAccept,
2573                                               &m_renameRes,
2574                                               this,
2575                                               s,
2576                                               wxPoint(x-4,y-4),
2577                                               wxSize(w+11,h+8));
2578     text->SetFocus();
2579 }
2580
2581 void wxGenericTreeCtrl::OnRenameTimer()
2582 {
2583     Edit( m_current );
2584 }
2585
2586 void wxGenericTreeCtrl::OnRenameAccept()
2587 {
2588     // TODO if the validator fails this causes a crash
2589     wxTreeEvent le( wxEVT_COMMAND_TREE_END_LABEL_EDIT, GetId() );
2590     le.m_item = (long) m_currentEdit;
2591     le.SetEventObject( this );
2592     le.m_label = m_renameRes;
2593     GetEventHandler()->ProcessEvent( le );
2594
2595     if (!le.IsAllowed()) return;
2596
2597     SetItemText( m_currentEdit, m_renameRes );
2598 }
2599
2600 void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
2601 {
2602     if ( !m_anchor ) return;
2603
2604     // we process left mouse up event (enables in-place edit), right down
2605     // (pass to the user code), left dbl click (activate item) and
2606     // dragging/moving events for items drag-and-drop
2607     if ( !(event.LeftDown() ||
2608            event.LeftUp() ||
2609            event.RightDown() ||
2610            event.LeftDClick() ||
2611            event.Dragging() ||
2612            ((event.Moving() || event.RightUp()) && m_isDragging)) )
2613     {
2614         event.Skip();
2615
2616         return;
2617     }
2618
2619     wxClientDC dc(this);
2620     PrepareDC(dc);
2621     wxCoord x = dc.DeviceToLogicalX( event.GetX() );
2622     wxCoord y = dc.DeviceToLogicalY( event.GetY() );
2623
2624     int flags = 0;
2625     wxGenericTreeItem *item = m_anchor->HitTest( wxPoint(x,y),
2626                                                  this,
2627                                                  flags,
2628                                                  0 );
2629
2630     if ( event.Dragging() && !m_isDragging )
2631     {
2632         if (m_dragCount == 0)
2633             m_dragStart = wxPoint(x,y);
2634
2635         m_dragCount++;
2636
2637         if (m_dragCount != 3)
2638         {
2639             // wait until user drags a bit further...
2640             return;
2641         }
2642
2643         wxEventType command = event.RightIsDown()
2644                               ? wxEVT_COMMAND_TREE_BEGIN_RDRAG
2645                               : wxEVT_COMMAND_TREE_BEGIN_DRAG;
2646
2647         wxTreeEvent nevent( command, GetId() );
2648         nevent.m_item = (long) m_current;
2649         nevent.SetEventObject(this);
2650
2651         // by default the dragging is not supported, the user code must
2652         // explicitly allow the event for it to take place
2653         nevent.Veto();
2654
2655         if ( GetEventHandler()->ProcessEvent(nevent) && nevent.IsAllowed() )
2656         {
2657             // we're going to drag this item
2658             m_isDragging = TRUE;
2659
2660             // remember the old cursor because we will change it while
2661             // dragging
2662             m_oldCursor = m_cursor;
2663
2664             // in a single selection control, hide the selection temporarily
2665             if ( !(GetWindowStyleFlag() & wxTR_MULTIPLE) )
2666             {
2667                 m_oldSelection = (wxGenericTreeItem*) GetSelection().m_pItem;
2668
2669                 if ( m_oldSelection )
2670                 {
2671                     m_oldSelection->SetHilight(FALSE);
2672                     RefreshLine(m_oldSelection);
2673                 }
2674             }
2675
2676             CaptureMouse();
2677         }
2678     }
2679     else if ( event.Moving() )
2680     {
2681         if ( item != m_dropTarget )
2682         {
2683             // unhighlight the previous drop target
2684             DrawDropEffect(m_dropTarget);
2685
2686             m_dropTarget = item;
2687
2688             // highlight the current drop target if any
2689             DrawDropEffect(m_dropTarget);
2690
2691             wxYieldIfNeeded();
2692         }
2693     }
2694     else if ( (event.LeftUp() || event.RightUp()) && m_isDragging )
2695     {
2696         // erase the highlighting
2697         DrawDropEffect(m_dropTarget);
2698
2699         if ( m_oldSelection )
2700         {
2701             m_oldSelection->SetHilight(TRUE);
2702             RefreshLine(m_oldSelection);
2703             m_oldSelection = (wxGenericTreeItem *)NULL;
2704         }
2705
2706         // generate the drag end event
2707         wxTreeEvent event(wxEVT_COMMAND_TREE_END_DRAG, GetId());
2708
2709         event.m_item = (long) item;
2710         event.m_pointDrag = wxPoint(x, y);
2711         event.SetEventObject(this);
2712
2713         (void)GetEventHandler()->ProcessEvent(event);
2714
2715         m_isDragging = FALSE;
2716         m_dropTarget = (wxGenericTreeItem *)NULL;
2717
2718         ReleaseMouse();
2719
2720         SetCursor(m_oldCursor);
2721
2722         wxYieldIfNeeded();
2723     }
2724     else
2725     {
2726         // here we process only the messages which happen on tree items
2727
2728         m_dragCount = 0;
2729
2730         if (item == NULL) return;  /* we hit the blank area */
2731
2732         if ( event.RightDown() )
2733         {
2734             wxTreeEvent nevent(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK, GetId());
2735             nevent.m_item = (long) item;
2736             CalcScrolledPosition(x, y,
2737                                  &nevent.m_pointDrag.x,
2738                                  &nevent.m_pointDrag.y);
2739             nevent.SetEventObject(this);
2740             GetEventHandler()->ProcessEvent(nevent);
2741         }
2742         else if ( event.LeftUp() )
2743         {
2744             if ( m_lastOnSame )
2745             {
2746                 if ( (item == m_current) &&
2747                      (flags & wxTREE_HITTEST_ONITEMLABEL) &&
2748                      HasFlag(wxTR_EDIT_LABELS) )
2749                 {
2750                     if ( m_renameTimer->IsRunning() )
2751                         m_renameTimer->Stop();
2752
2753                     m_renameTimer->Start( 100, TRUE );
2754                 }
2755
2756                 m_lastOnSame = FALSE;
2757             }
2758         }
2759         else // !RightDown() && !LeftUp() ==> LeftDown() || LeftDClick()
2760         {
2761             if ( event.LeftDown() )
2762             {
2763                 m_lastOnSame = item == m_current;
2764             }
2765
2766             if ( flags & wxTREE_HITTEST_ONITEMBUTTON )
2767             {
2768                 // only toggle the item for a single click, double click on
2769                 // the button doesn't do anything (it toggles the item twice)
2770                 if ( event.LeftDown() )
2771                 {
2772                     Toggle( item );
2773                 }
2774
2775                 // don't select the item if the button was clicked
2776                 return;
2777             }
2778
2779             // how should the selection work for this event?
2780             bool is_multiple, extended_select, unselect_others;
2781             EventFlagsToSelType(GetWindowStyleFlag(),
2782                                 event.ShiftDown(),
2783                                 event.ControlDown(),
2784                                 is_multiple, extended_select, unselect_others);
2785
2786             SelectItem(item, unselect_others, extended_select);
2787
2788             // For some reason, Windows isn't recognizing a left double-click,
2789             // so we need to simulate it here.  Allow 200 milliseconds for now.
2790             if ( event.LeftDClick() )
2791             {
2792                 // double clicking should not start editing the item label
2793                 m_renameTimer->Stop();
2794                 m_lastOnSame = FALSE;
2795
2796                 // send activate event first
2797                 wxTreeEvent nevent( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
2798                 nevent.m_item = (long) item;
2799                 CalcScrolledPosition(x, y,
2800                                      &nevent.m_pointDrag.x,
2801                                      &nevent.m_pointDrag.y);
2802                 nevent.SetEventObject( this );
2803                 if ( !GetEventHandler()->ProcessEvent( nevent ) )
2804                 {
2805                     // if the user code didn't process the activate event,
2806                     // handle it ourselves by toggling the item when it is
2807                     // double clicked
2808                     if ( item->HasPlus() )
2809                     {
2810                         Toggle(item);
2811                     }
2812                 }
2813             }
2814         }
2815     }
2816 }
2817
2818 void wxGenericTreeCtrl::OnIdle( wxIdleEvent &WXUNUSED(event) )
2819 {
2820     /* after all changes have been done to the tree control,
2821      * we actually redraw the tree when everything is over */
2822
2823     if (!m_dirty) return;
2824
2825     m_dirty = FALSE;
2826
2827     CalculatePositions();
2828     Refresh();
2829     AdjustMyScrollbars();
2830 }
2831
2832 void wxGenericTreeCtrl::CalculateSize( wxGenericTreeItem *item, wxDC &dc )
2833 {
2834     wxCoord text_w = 0;
2835     wxCoord text_h = 0;
2836
2837     if (item->IsBold())
2838         dc.SetFont(m_boldFont);
2839
2840     dc.GetTextExtent( item->GetText(), &text_w, &text_h );
2841     text_h+=2;
2842
2843     // restore normal font
2844     dc.SetFont( m_normalFont );
2845
2846     int image_h = 0;
2847     int image_w = 0;
2848     int image = item->GetCurrentImage();
2849     if ( image != NO_IMAGE )
2850     {
2851         if ( m_imageListNormal )
2852         {
2853             m_imageListNormal->GetSize( image, image_w, image_h );
2854             image_w += 4;
2855         }
2856     }
2857
2858     int total_h = (image_h > text_h) ? image_h : text_h;
2859
2860     if (total_h < 30)
2861         total_h += 2;            // at least 2 pixels
2862     else
2863         total_h += total_h/10;   // otherwise 10% extra spacing
2864
2865     item->SetHeight(total_h);
2866     if (total_h>m_lineHeight)
2867         m_lineHeight=total_h;
2868
2869     item->SetWidth(image_w+text_w+2);
2870 }
2871
2872 // -----------------------------------------------------------------------------
2873 // for developper : y is now the top of the level
2874 // not the middle of it !
2875 void wxGenericTreeCtrl::CalculateLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y )
2876 {
2877     int x = level*m_indent;
2878     if (!HasFlag(wxTR_HIDE_ROOT))
2879     {
2880         x += m_indent;
2881     }
2882     else if (level == 0)
2883     {
2884         // a hidden root is not evaluated, but its
2885         // children are always calculated
2886         goto Recurse;
2887     }
2888
2889     CalculateSize( item, dc );
2890
2891     // set its position
2892     item->SetX( x+m_spacing );
2893     item->SetY( y );
2894     y += GetLineHeight(item);
2895
2896     if ( !item->IsExpanded() )
2897     {
2898         // we don't need to calculate collapsed branches
2899         return;
2900     }
2901
2902   Recurse:
2903     wxArrayGenericTreeItems& children = item->GetChildren();
2904     size_t n, count = children.Count();
2905     ++level;
2906     for (n = 0; n < count; ++n )
2907         CalculateLevel( children[n], dc, level, y );  // recurse
2908 }
2909
2910 void wxGenericTreeCtrl::CalculatePositions()
2911 {
2912     if ( !m_anchor ) return;
2913
2914     wxClientDC dc(this);
2915     PrepareDC( dc );
2916
2917     dc.SetFont( m_normalFont );
2918
2919     dc.SetPen( m_dottedPen );
2920     //if(GetImageList() == NULL)
2921     // m_lineHeight = (int)(dc.GetCharHeight() + 4);
2922
2923     int y = 2;
2924     CalculateLevel( m_anchor, dc, 0, y ); // start recursion
2925 }
2926
2927 void wxGenericTreeCtrl::RefreshSubtree(wxGenericTreeItem *item)
2928 {
2929     if (m_dirty) return;
2930
2931     wxClientDC dc(this);
2932     PrepareDC(dc);
2933
2934     int cw = 0;
2935     int ch = 0;
2936     GetClientSize( &cw, &ch );
2937
2938     wxRect rect;
2939     rect.x = dc.LogicalToDeviceX( 0 );
2940     rect.width = cw;
2941     rect.y = dc.LogicalToDeviceY( item->GetY() );
2942     rect.height = ch;
2943
2944     Refresh( TRUE, &rect );
2945
2946     AdjustMyScrollbars();
2947 }
2948
2949 void wxGenericTreeCtrl::RefreshLine( wxGenericTreeItem *item )
2950 {
2951     if (m_dirty) return;
2952
2953     wxClientDC dc(this);
2954     PrepareDC( dc );
2955
2956     int cw = 0;
2957     int ch = 0;
2958     GetClientSize( &cw, &ch );
2959
2960     wxRect rect;
2961     rect.x = dc.LogicalToDeviceX( 0 );
2962     rect.y = dc.LogicalToDeviceY( item->GetY() );
2963     rect.width = cw;
2964     rect.height = GetLineHeight(item); //dc.GetCharHeight() + 6;
2965
2966     Refresh( TRUE, &rect );
2967 }
2968
2969 void wxGenericTreeCtrl::RefreshSelected()
2970 {
2971     // TODO: this is awfully inefficient, we should keep the list of all
2972     //       selected items internally, should be much faster
2973     if ( m_anchor )
2974         RefreshSelectedUnder(m_anchor);
2975 }
2976
2977 void wxGenericTreeCtrl::RefreshSelectedUnder(wxGenericTreeItem *item)
2978 {
2979     if ( item->IsSelected() )
2980         RefreshLine(item);
2981
2982     const wxArrayGenericTreeItems& children = item->GetChildren();
2983     size_t count = children.GetCount();
2984     for ( size_t n = 0; n < count; n++ )
2985     {
2986         RefreshSelectedUnder(children[n]);
2987     }
2988 }
2989
2990 // ----------------------------------------------------------------------------
2991 // changing colours: we need to refresh the tree control
2992 // ----------------------------------------------------------------------------
2993
2994 bool wxGenericTreeCtrl::SetBackgroundColour(const wxColour& colour)
2995 {
2996     if ( !wxWindow::SetBackgroundColour(colour) )
2997         return FALSE;
2998
2999     Refresh();
3000
3001     return TRUE;
3002 }
3003
3004 bool wxGenericTreeCtrl::SetForegroundColour(const wxColour& colour)
3005 {
3006     if ( !wxWindow::SetForegroundColour(colour) )
3007         return FALSE;
3008
3009     Refresh();
3010
3011     return TRUE;
3012 }
3013
3014 #endif // wxUSE_TREECTRL