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