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 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 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::GetSystemColour
 673                             (
 674                                 wxSYS_COLOUR_HIGHLIGHT
 675                             ),
 676                             wxSOLID
 677                          );
 678
 679     m_hilightUnfocusedBrush = new wxBrush
 680                               (
 681                                  wxSystemSettings::GetSystemColour
 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::GetSystemFont( 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     SetBackgroundColour( wxSystemSettings::GetSystemColour( wxSYS_COLOUR_LISTBOX ) );
 758
 759 //  m_dottedPen = wxPen( "grey", 0, wxDOT );  too slow under XFree86
 760     m_dottedPen = wxPen( wxT("grey"), 0, 0 );
 761
 762     return TRUE;
 763 }
 764
 765 wxGenericTreeCtrl::~wxGenericTreeCtrl()
 766 {
 767     delete m_hilightBrush;
 768     delete m_hilightUnfocusedBrush;
 769
 770     if (m_arrowRight) delete m_arrowRight;
 771     if (m_arrowDown) delete m_arrowDown;
 772
 773     DeleteAllItems();
 774
 775     delete m_renameTimer;
 776     if (m_ownsImageListNormal) delete m_imageListNormal;
 777     if (m_ownsImageListState) delete m_imageListState;
 778     if (m_ownsImageListButtons) delete m_imageListButtons;
 779 }
 780
 781 // -----------------------------------------------------------------------------
 782 // accessors
 783 // -----------------------------------------------------------------------------
 784
 785 size_t wxGenericTreeCtrl::GetCount() const
 786 {
 787     return m_anchor == NULL ? 0u : m_anchor->GetChildrenCount();
 788 }
 789
 790 void wxGenericTreeCtrl::SetIndent(unsigned int indent)
 791 {
 792     m_indent = indent;
 793     m_dirty = TRUE;
 794 }
 795
 796 void wxGenericTreeCtrl::SetSpacing(unsigned int spacing)
 797 {
 798     m_spacing = spacing;
 799     m_dirty = TRUE;
 800 }
 801
 802 size_t wxGenericTreeCtrl::GetChildrenCount(const wxTreeItemId& item, bool recursively)
 803 {
 804     wxCHECK_MSG( item.IsOk(), 0u, wxT("invalid tree item") );
 805
 806     return ((wxGenericTreeItem*) item.m_pItem)->GetChildrenCount(recursively);
 807 }
 808
 809 void wxGenericTreeCtrl::SetWindowStyle(const long styles)
 810 {
 811         // right now, just sets the styles.  Eventually, we may
 812         // want to update the inherited styles, but right now
 813         // none of the parents has updatable styles
 814     m_windowStyle = styles;
 815     m_dirty = TRUE;
 816 }
 817
 818 // -----------------------------------------------------------------------------
 819 // functions to work with tree items
 820 // -----------------------------------------------------------------------------
 821
 822 wxString wxGenericTreeCtrl::GetItemText(const wxTreeItemId& item) const
 823 {
 824     wxCHECK_MSG( item.IsOk(), wxT(""), wxT("invalid tree item") );
 825
 826     return ((wxGenericTreeItem*) item.m_pItem)->GetText();
 827 }
 828
 829 int wxGenericTreeCtrl::GetItemImage(const wxTreeItemId& item,
 830                              wxTreeItemIcon which) const
 831 {
 832     wxCHECK_MSG( item.IsOk(), -1, wxT("invalid tree item") );
 833
 834     return ((wxGenericTreeItem*) item.m_pItem)->GetImage(which);
 835 }
 836
 837 wxTreeItemData *wxGenericTreeCtrl::GetItemData(const wxTreeItemId& item) const
 838 {
 839     wxCHECK_MSG( item.IsOk(), NULL, wxT("invalid tree item") );
 840
 841     return ((wxGenericTreeItem*) item.m_pItem)->GetData();
 842 }
 843
 844 void wxGenericTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text)
 845 {
 846     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
 847
 848     wxClientDC dc(this);
 849     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
 850     pItem->SetText(text);
 851     CalculateSize(pItem, dc);
 852     RefreshLine(pItem);
 853 }
 854
 855 void wxGenericTreeCtrl::SetItemImage(const wxTreeItemId& item,
 856                               int image,
 857                               wxTreeItemIcon which)
 858 {
 859     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
 860
 861     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
 862     pItem->SetImage(image, which);
 863
 864     wxClientDC dc(this);
 865     CalculateSize(pItem, dc);
 866     RefreshLine(pItem);
 867 }
 868
 869 void wxGenericTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data)
 870 {
 871     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
 872
 873     ((wxGenericTreeItem*) item.m_pItem)->SetData(data);
 874 }
 875
 876 void wxGenericTreeCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
 877 {
 878     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
 879
 880     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
 881     pItem->SetHasPlus(has);
 882     RefreshLine(pItem);
 883 }
 884
 885 void wxGenericTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
 886 {
 887     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
 888
 889     // avoid redrawing the tree if no real change
 890     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
 891     if ( pItem->IsBold() != bold )
 892     {
 893         pItem->SetBold(bold);
 894         RefreshLine(pItem);
 895     }
 896 }
 897
 898 void wxGenericTreeCtrl::SetItemTextColour(const wxTreeItemId& item,
 899                                    const wxColour& col)
 900 {
 901     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
 902
 903     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
 904     pItem->Attr().SetTextColour(col);
 905     RefreshLine(pItem);
 906 }
 907
 908 void wxGenericTreeCtrl::SetItemBackgroundColour(const wxTreeItemId& item,
 909                                          const wxColour& col)
 910 {
 911     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
 912
 913     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
 914     pItem->Attr().SetBackgroundColour(col);
 915     RefreshLine(pItem);
 916 }
 917
 918 void wxGenericTreeCtrl::SetItemFont(const wxTreeItemId& item, const wxFont& font)
 919 {
 920     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
 921
 922     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
 923     pItem->Attr().SetFont(font);
 924     RefreshLine(pItem);
 925 }
 926
 927 bool wxGenericTreeCtrl::SetFont( const wxFont &font )
 928 {
 929     wxScrolledWindow::SetFont(font);
 930
 931     m_normalFont = font ;
 932     m_boldFont = wxFont( m_normalFont.GetPointSize(),
 933                             m_normalFont.GetFamily(),
 934                             m_normalFont.GetStyle(),
 935                             wxBOLD,
 936                             m_normalFont.GetUnderlined());
 937
 938     return TRUE;
 939 }
 940
 941
 942 // -----------------------------------------------------------------------------
 943 // item status inquiries
 944 // -----------------------------------------------------------------------------
 945
 946 bool wxGenericTreeCtrl::IsVisible(const wxTreeItemId& item) const
 947 {
 948     wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
 949
 950     // An item is only visible if it's not a descendant of a collapsed item
 951     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
 952     wxGenericTreeItem* parent = pItem->GetParent();
 953     while (parent)
 954     {
 955         if (!parent->IsExpanded())
 956             return FALSE;
 957         parent = parent->GetParent();
 958     }
 959
 960     int startX, startY;
 961     GetViewStart(& startX, & startY);
 962
 963     wxSize clientSize = GetClientSize();
 964
 965     wxRect rect;
 966     if (!GetBoundingRect(item, rect))
 967         return FALSE;
 968     if (rect.GetWidth() == 0 || rect.GetHeight() == 0)
 969         return FALSE;
 970     if (rect.GetBottom() < 0 || rect.GetTop() > clientSize.y)
 971         return FALSE;
 972     if (rect.GetRight() < 0 || rect.GetLeft() > clientSize.x)
 973         return FALSE;
 974
 975     return TRUE;
 976 }
 977
 978 bool wxGenericTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const
 979 {
 980     wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
 981
 982     // consider that the item does have children if it has the "+" button: it
 983     // might not have them (if it had never been expanded yet) but then it
 984     // could have them as well and it's better to err on this side rather than
 985     // disabling some operations which are restricted to the items with
 986     // children for an item which does have them
 987     return ((wxGenericTreeItem*) item.m_pItem)->HasPlus();
 988 }
 989
 990 bool wxGenericTreeCtrl::IsExpanded(const wxTreeItemId& item) const
 991 {
 992     wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
 993
 994     return ((wxGenericTreeItem*) item.m_pItem)->IsExpanded();
 995 }
 996
 997 bool wxGenericTreeCtrl::IsSelected(const wxTreeItemId& item) const
 998 {
 999     wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
1000
1001     return ((wxGenericTreeItem*) item.m_pItem)->IsSelected();
1002 }
1003
1004 bool wxGenericTreeCtrl::IsBold(const wxTreeItemId& item) const
1005 {
1006     wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
1007
1008     return ((wxGenericTreeItem*) item.m_pItem)->IsBold();
1009 }
1010
1011 // -----------------------------------------------------------------------------
1012 // navigation
1013 // -----------------------------------------------------------------------------
1014
1015 wxTreeItemId wxGenericTreeCtrl::GetParent(const wxTreeItemId& item) const
1016 {
1017     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1018
1019     return ((wxGenericTreeItem*) item.m_pItem)->GetParent();
1020 }
1021
1022 wxTreeItemId wxGenericTreeCtrl::GetFirstChild(const wxTreeItemId& item, long& cookie) const
1023 {
1024     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1025
1026     cookie = 0;
1027     return GetNextChild(item, cookie);
1028 }
1029
1030 wxTreeItemId wxGenericTreeCtrl::GetNextChild(const wxTreeItemId& item, long& cookie) const
1031 {
1032     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1033
1034     wxArrayGenericTreeItems& children = ((wxGenericTreeItem*) item.m_pItem)->GetChildren();
1035     if ( (size_t)cookie < children.Count() )
1036     {
1037         return children.Item((size_t)cookie++);
1038     }
1039     else
1040     {
1041         // there are no more of them
1042         return wxTreeItemId();
1043     }
1044 }
1045
1046 wxTreeItemId wxGenericTreeCtrl::GetLastChild(const wxTreeItemId& item) const
1047 {
1048     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1049
1050     wxArrayGenericTreeItems& children = ((wxGenericTreeItem*) item.m_pItem)->GetChildren();
1051     return (children.IsEmpty() ? wxTreeItemId() : wxTreeItemId(children.Last()));
1052 }
1053
1054 wxTreeItemId wxGenericTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
1055 {
1056     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1057
1058     wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
1059     wxGenericTreeItem *parent = i->GetParent();
1060     if ( parent == NULL )
1061     {
1062         // root item doesn't have any siblings
1063         return wxTreeItemId();
1064     }
1065
1066     wxArrayGenericTreeItems& siblings = parent->GetChildren();
1067     int index = siblings.Index(i);
1068     wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
1069
1070     size_t n = (size_t)(index + 1);
1071     return n == siblings.Count() ? wxTreeItemId() : wxTreeItemId(siblings[n]);
1072 }
1073
1074 wxTreeItemId wxGenericTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const
1075 {
1076     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1077
1078     wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
1079     wxGenericTreeItem *parent = i->GetParent();
1080     if ( parent == NULL )
1081     {
1082         // root item doesn't have any siblings
1083         return wxTreeItemId();
1084     }
1085
1086     wxArrayGenericTreeItems& siblings = parent->GetChildren();
1087     int index = siblings.Index(i);
1088     wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
1089
1090     return index == 0 ? wxTreeItemId()
1091                       : wxTreeItemId(siblings[(size_t)(index - 1)]);
1092 }
1093
1094 // Only for internal use right now, but should probably be public
1095 wxTreeItemId wxGenericTreeCtrl::GetNext(const wxTreeItemId& item) const
1096 {
1097     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1098
1099     wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
1100
1101     // First see if there are any children.
1102     wxArrayGenericTreeItems& children = i->GetChildren();
1103     if (children.GetCount() > 0)
1104     {
1105          return children.Item(0);
1106     }
1107     else
1108     {
1109          // Try a sibling of this or ancestor instead
1110          wxTreeItemId p = item;
1111          wxTreeItemId toFind;
1112          do
1113          {
1114               toFind = GetNextSibling(p);
1115               p = GetParent(p);
1116          } while (p.IsOk() && !toFind.IsOk());
1117          return toFind;
1118     }
1119 }
1120
1121 wxTreeItemId wxGenericTreeCtrl::GetFirstVisibleItem() const
1122 {
1123     wxTreeItemId id = GetRootItem();
1124     if (!id.IsOk())
1125         return id;
1126
1127     do
1128     {
1129         if (IsVisible(id))
1130               return id;
1131         id = GetNext(id);
1132     } while (id.IsOk());
1133
1134     return wxTreeItemId();
1135 }
1136
1137 wxTreeItemId wxGenericTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
1138 {
1139     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1140
1141     wxTreeItemId id = item;
1142     if (id.IsOk())
1143     {
1144         while (id = GetNext(id), id.IsOk())
1145         {
1146             if (IsVisible(id))
1147                 return id;
1148         }
1149     }
1150     return wxTreeItemId();
1151 }
1152
1153 wxTreeItemId wxGenericTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
1154 {
1155     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
1156
1157     wxFAIL_MSG(wxT("not implemented"));
1158
1159     return wxTreeItemId();
1160 }
1161
1162 // -----------------------------------------------------------------------------
1163 // operations
1164 // -----------------------------------------------------------------------------
1165
1166 wxTreeItemId wxGenericTreeCtrl::DoInsertItem(const wxTreeItemId& parentId,
1167                                       size_t previous,
1168                                       const wxString& text,
1169                                       int image, int selImage,
1170                                       wxTreeItemData *data)
1171 {
1172     wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem;
1173     if ( !parent )
1174     {
1175         // should we give a warning here?
1176         return AddRoot(text, image, selImage, data);
1177     }
1178
1179     m_dirty = TRUE;     // do this first so stuff below doesn't cause flicker
1180
1181     wxGenericTreeItem *item =
1182         new wxGenericTreeItem( parent, text, image, selImage, data );
1183
1184     if ( data != NULL )
1185     {
1186         data->m_pItem = (long) item;
1187     }
1188
1189     parent->Insert( item, previous );
1190
1191     return item;
1192 }
1193
1194 wxTreeItemId wxGenericTreeCtrl::AddRoot(const wxString& text,
1195                                  int image, int selImage,
1196                                  wxTreeItemData *data)
1197 {
1198     wxCHECK_MSG( !m_anchor, wxTreeItemId(), wxT("tree can have only one root") );
1199
1200     m_dirty = TRUE;     // do this first so stuff below doesn't cause flicker
1201
1202     m_anchor = new wxGenericTreeItem((wxGenericTreeItem *)NULL, text,
1203                                    image, selImage, data);
1204     if (HasFlag(wxTR_HIDE_ROOT))
1205     {
1206         // if root is hidden, make sure we can navigate
1207         // into children
1208         m_anchor->SetHasPlus();
1209         Expand(m_anchor);
1210     }
1211     if ( data != NULL )
1212     {
1213         data->m_pItem = (long) m_anchor;
1214     }
1215
1216     if (!HasFlag(wxTR_MULTIPLE))
1217     {
1218         m_current = m_key_current = m_anchor;
1219         m_current->SetHilight( TRUE );
1220     }
1221
1222     return m_anchor;
1223 }
1224
1225 wxTreeItemId wxGenericTreeCtrl::PrependItem(const wxTreeItemId& parent,
1226                                      const wxString& text,
1227                                      int image, int selImage,
1228                                      wxTreeItemData *data)
1229 {
1230     return DoInsertItem(parent, 0u, text, image, selImage, data);
1231 }
1232
1233 wxTreeItemId wxGenericTreeCtrl::InsertItem(const wxTreeItemId& parentId,
1234                                     const wxTreeItemId& idPrevious,
1235                                     const wxString& text,
1236                                     int image, int selImage,
1237                                     wxTreeItemData *data)
1238 {
1239     wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem;
1240     if ( !parent )
1241     {
1242         // should we give a warning here?
1243         return AddRoot(text, image, selImage, data);
1244     }
1245
1246     int index = parent->GetChildren().Index((wxGenericTreeItem*) idPrevious.m_pItem);
1247     wxASSERT_MSG( index != wxNOT_FOUND,
1248                   wxT("previous item in wxGenericTreeCtrl::InsertItem() is not a sibling") );
1249
1250     return DoInsertItem(parentId, (size_t)++index, text, image, selImage, data);
1251 }
1252
1253 wxTreeItemId wxGenericTreeCtrl::InsertItem(const wxTreeItemId& parentId,
1254                                     size_t before,
1255                                     const wxString& text,
1256                                     int image, int selImage,
1257                                     wxTreeItemData *data)
1258 {
1259     wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem;
1260     if ( !parent )
1261     {
1262         // should we give a warning here?
1263         return AddRoot(text, image, selImage, data);
1264     }
1265
1266     return DoInsertItem(parentId, before, text, image, selImage, data);
1267 }
1268
1269 wxTreeItemId wxGenericTreeCtrl::AppendItem(const wxTreeItemId& parentId,
1270                                     const wxString& text,
1271                                     int image, int selImage,
1272                                     wxTreeItemData *data)
1273 {
1274     wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem;
1275     if ( !parent )
1276     {
1277         // should we give a warning here?
1278         return AddRoot(text, image, selImage, data);
1279     }
1280
1281     return DoInsertItem( parent, parent->GetChildren().Count(), text,
1282                          image, selImage, data);
1283 }
1284
1285 void wxGenericTreeCtrl::SendDeleteEvent(wxGenericTreeItem *item)
1286 {
1287     wxTreeEvent event( wxEVT_COMMAND_TREE_DELETE_ITEM, GetId() );
1288     event.m_item = (long) item;
1289     event.SetEventObject( this );
1290     ProcessEvent( event );
1291 }
1292
1293 void wxGenericTreeCtrl::DeleteChildren(const wxTreeItemId& itemId)
1294 {
1295     m_dirty = TRUE;     // do this first so stuff below doesn't cause flicker
1296
1297     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1298     item->DeleteChildren(this);
1299 }
1300
1301 void wxGenericTreeCtrl::Delete(const wxTreeItemId& itemId)
1302 {
1303     m_dirty = TRUE;     // do this first so stuff below doesn't cause flicker
1304
1305     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1306
1307     // don't stay with invalid m_key_current or we will crash in
1308     // the next call to OnChar()
1309     bool changeKeyCurrent = FALSE;
1310     wxGenericTreeItem *itemKey = m_key_current;
1311     while ( itemKey )
1312     {
1313         if ( itemKey == item )
1314         {
1315             // m_key_current is a descendant of the item being deleted
1316             changeKeyCurrent = TRUE;
1317             break;
1318         }
1319         itemKey = itemKey->GetParent();
1320     }
1321
1322     wxGenericTreeItem *parent = item->GetParent();
1323     if ( parent )
1324     {
1325         parent->GetChildren().Remove( item );  // remove by value
1326     }
1327
1328     if ( changeKeyCurrent )
1329     {
1330         // may be NULL or not
1331         m_key_current = parent;
1332     }
1333
1334     item->DeleteChildren(this);
1335     SendDeleteEvent(item);
1336     delete item;
1337 }
1338
1339 void wxGenericTreeCtrl::DeleteAllItems()
1340 {
1341     if ( m_anchor )
1342     {
1343         m_dirty = TRUE;
1344
1345         m_anchor->DeleteChildren(this);
1346         delete m_anchor;
1347
1348         m_anchor = NULL;
1349     }
1350 }
1351
1352 void wxGenericTreeCtrl::Expand(const wxTreeItemId& itemId)
1353 {
1354     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1355
1356     wxCHECK_RET( item, _T("invalid item in wxGenericTreeCtrl::Expand") );
1357
1358     if ( !item->HasPlus() )
1359         return;
1360
1361     if ( item->IsExpanded() )
1362         return;
1363
1364     wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_EXPANDING, GetId() );
1365     event.m_item = (long) item;
1366     event.SetEventObject( this );
1367
1368     if ( ProcessEvent( event ) && !event.IsAllowed() )
1369     {
1370         // cancelled by program
1371         return;
1372     }
1373
1374     item->Expand();
1375     CalculatePositions();
1376
1377     RefreshSubtree(item);
1378
1379     event.SetEventType(wxEVT_COMMAND_TREE_ITEM_EXPANDED);
1380     ProcessEvent( event );
1381 }
1382
1383 void wxGenericTreeCtrl::ExpandAll(const wxTreeItemId& item)
1384 {
1385     Expand(item);
1386     if ( IsExpanded(item) )
1387     {
1388         long cookie;
1389         wxTreeItemId child = GetFirstChild(item, cookie);
1390         while ( child.IsOk() )
1391         {
1392             ExpandAll(child);
1393
1394             child = GetNextChild(item, cookie);
1395         }
1396     }
1397 }
1398
1399 void wxGenericTreeCtrl::Collapse(const wxTreeItemId& itemId)
1400 {
1401     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1402
1403     if ( !item->IsExpanded() )
1404         return;
1405
1406     wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_COLLAPSING, GetId() );
1407     event.m_item = (long) item;
1408     event.SetEventObject( this );
1409     if ( ProcessEvent( event ) && !event.IsAllowed() )
1410     {
1411         // cancelled by program
1412         return;
1413     }
1414
1415     item->Collapse();
1416
1417 #if 0  // TODO why should items be collapsed recursively?
1418     wxArrayGenericTreeItems& children = item->GetChildren();
1419     size_t count = children.Count();
1420     for ( size_t n = 0; n < count; n++ )
1421     {
1422         Collapse(children[n]);
1423     }
1424 #endif
1425
1426     CalculatePositions();
1427
1428     RefreshSubtree(item);
1429
1430     event.SetEventType(wxEVT_COMMAND_TREE_ITEM_COLLAPSED);
1431     ProcessEvent( event );
1432 }
1433
1434 void wxGenericTreeCtrl::CollapseAndReset(const wxTreeItemId& item)
1435 {
1436     Collapse(item);
1437     DeleteChildren(item);
1438 }
1439
1440 void wxGenericTreeCtrl::Toggle(const wxTreeItemId& itemId)
1441 {
1442     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1443
1444     if (item->IsExpanded())
1445         Collapse(itemId);
1446     else
1447         Expand(itemId);
1448 }
1449
1450 void wxGenericTreeCtrl::Unselect()
1451 {
1452     if (m_current)
1453     {
1454         m_current->SetHilight( FALSE );
1455         RefreshLine( m_current );
1456     }
1457 }
1458
1459 void wxGenericTreeCtrl::UnselectAllChildren(wxGenericTreeItem *item)
1460 {
1461     if (item->IsSelected())
1462     {
1463         item->SetHilight(FALSE);
1464         RefreshLine(item);
1465     }
1466
1467     if (item->HasChildren())
1468     {
1469         wxArrayGenericTreeItems& children = item->GetChildren();
1470         size_t count = children.Count();
1471         for ( size_t n = 0; n < count; ++n )
1472         {
1473             UnselectAllChildren(children[n]);
1474         }
1475     }
1476 }
1477
1478 void wxGenericTreeCtrl::UnselectAll()
1479 {
1480     wxTreeItemId rootItem = GetRootItem();
1481
1482     // the tree might not have the root item at all
1483     if ( rootItem )
1484     {
1485         UnselectAllChildren((wxGenericTreeItem*) rootItem.m_pItem);
1486     }
1487 }
1488
1489 // Recursive function !
1490 // To stop we must have crt_item<last_item
1491 // Algorithm :
1492 // Tag all next children, when no more children,
1493 // Move to parent (not to tag)
1494 // Keep going... if we found last_item, we stop.
1495 bool wxGenericTreeCtrl::TagNextChildren(wxGenericTreeItem *crt_item, wxGenericTreeItem *last_item, bool select)
1496 {
1497     wxGenericTreeItem *parent = crt_item->GetParent();
1498
1499     if (parent == NULL) // This is root item
1500         return TagAllChildrenUntilLast(crt_item, last_item, select);
1501
1502     wxArrayGenericTreeItems& children = parent->GetChildren();
1503     int index = children.Index(crt_item);
1504     wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
1505
1506     size_t count = children.Count();
1507     for (size_t n=(size_t)(index+1); n<count; ++n)
1508     {
1509         if (TagAllChildrenUntilLast(children[n], last_item, select)) return TRUE;
1510     }
1511
1512     return TagNextChildren(parent, last_item, select);
1513 }
1514
1515 bool wxGenericTreeCtrl::TagAllChildrenUntilLast(wxGenericTreeItem *crt_item, wxGenericTreeItem *last_item, bool select)
1516 {
1517     crt_item->SetHilight(select);
1518     RefreshLine(crt_item);
1519
1520     if (crt_item==last_item)
1521         return TRUE;
1522
1523     if (crt_item->HasChildren())
1524     {
1525         wxArrayGenericTreeItems& children = crt_item->GetChildren();
1526         size_t count = children.Count();
1527         for ( size_t n = 0; n < count; ++n )
1528         {
1529             if (TagAllChildrenUntilLast(children[n], last_item, select))
1530                 return TRUE;
1531         }
1532     }
1533
1534   return FALSE;
1535 }
1536
1537 void wxGenericTreeCtrl::SelectItemRange(wxGenericTreeItem *item1, wxGenericTreeItem *item2)
1538 {
1539     // item2 is not necessary after item1
1540     wxGenericTreeItem *first=NULL, *last=NULL;
1541
1542     // choice first' and 'last' between item1 and item2
1543     if (item1->GetY()<item2->GetY())
1544     {
1545         first=item1;
1546         last=item2;
1547     }
1548     else
1549     {
1550         first=item2;
1551         last=item1;
1552     }
1553
1554     bool select = m_current->IsSelected();
1555
1556     if ( TagAllChildrenUntilLast(first,last,select) )
1557         return;
1558
1559     TagNextChildren(first,last,select);
1560 }
1561
1562 void wxGenericTreeCtrl::SelectItem(const wxTreeItemId& itemId,
1563                             bool unselect_others,
1564                             bool extended_select)
1565 {
1566     wxCHECK_RET( itemId.IsOk(), wxT("invalid tree item") );
1567
1568     bool is_single=!(GetWindowStyleFlag() & wxTR_MULTIPLE);
1569     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1570
1571     //wxCHECK_RET( ( (!unselect_others) && is_single),
1572     //           wxT("this is a single selection tree") );
1573
1574     // to keep going anyhow !!!
1575     if (is_single)
1576     {
1577         if (item->IsSelected())
1578             return; // nothing to do
1579         unselect_others = TRUE;
1580         extended_select = FALSE;
1581     }
1582     else if ( unselect_others && item->IsSelected() )
1583     {
1584         // selection change if there is more than one item currently selected
1585         wxArrayTreeItemIds selected_items;
1586         if ( GetSelections(selected_items) == 1 )
1587             return;
1588     }
1589
1590     wxTreeEvent event( wxEVT_COMMAND_TREE_SEL_CHANGING, GetId() );
1591     event.m_item = (long) item;
1592     event.m_itemOld = (long) m_current;
1593     event.SetEventObject( this );
1594     // TODO : Here we don't send any selection mode yet !
1595
1596     if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() )
1597         return;
1598
1599     wxTreeItemId parent = GetParent( itemId );
1600     while (parent.IsOk())
1601     {
1602         if (!IsExpanded(parent))
1603             Expand( parent );
1604
1605         parent = GetParent( parent );
1606     }
1607
1608     EnsureVisible( itemId );
1609
1610     // ctrl press
1611     if (unselect_others)
1612     {
1613         if (is_single) Unselect(); // to speed up thing
1614         else UnselectAll();
1615     }
1616
1617     // shift press
1618     if (extended_select)
1619     {
1620         if ( !m_current )
1621         {
1622             m_current = m_key_current = (wxGenericTreeItem*) GetRootItem().m_pItem;
1623         }
1624
1625         // don't change the mark (m_current)
1626         SelectItemRange(m_current, item);
1627     }
1628     else
1629     {
1630         bool select=TRUE; // the default
1631
1632         // Check if we need to toggle hilight (ctrl mode)
1633         if (!unselect_others)
1634             select=!item->IsSelected();
1635
1636         m_current = m_key_current = item;
1637         m_current->SetHilight(select);
1638         RefreshLine( m_current );
1639     }
1640
1641     event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
1642     GetEventHandler()->ProcessEvent( event );
1643 }
1644
1645 void wxGenericTreeCtrl::FillArray(wxGenericTreeItem *item,
1646                            wxArrayTreeItemIds &array) const
1647 {
1648     if ( item->IsSelected() )
1649         array.Add(wxTreeItemId(item));
1650
1651     if ( item->HasChildren() )
1652     {
1653         wxArrayGenericTreeItems& children = item->GetChildren();
1654         size_t count = children.GetCount();
1655         for ( size_t n = 0; n < count; ++n )
1656             FillArray(children[n], array);
1657     }
1658 }
1659
1660 size_t wxGenericTreeCtrl::GetSelections(wxArrayTreeItemIds &array) const
1661 {
1662     array.Empty();
1663     wxTreeItemId idRoot = GetRootItem();
1664     if ( idRoot.IsOk() )
1665     {
1666         FillArray((wxGenericTreeItem*) idRoot.m_pItem, array);
1667     }
1668     //else: the tree is empty, so no selections
1669
1670     return array.Count();
1671 }
1672
1673 void wxGenericTreeCtrl::EnsureVisible(const wxTreeItemId& item)
1674 {
1675     if (!item.IsOk()) return;
1676
1677     wxGenericTreeItem *gitem = (wxGenericTreeItem*) item.m_pItem;
1678
1679     // first expand all parent branches
1680     wxGenericTreeItem *parent = gitem->GetParent();
1681     while ( parent )
1682     {
1683         Expand(parent);
1684         parent = parent->GetParent();
1685     }
1686
1687     //if (parent) CalculatePositions();
1688
1689     ScrollTo(item);
1690 }
1691
1692 void wxGenericTreeCtrl::ScrollTo(const wxTreeItemId &item)
1693 {
1694     if (!item.IsOk()) return;
1695
1696     // We have to call this here because the label in
1697     // question might just have been added and no screen
1698     // update taken place.
1699     if (m_dirty) wxYieldIfNeeded();
1700
1701     wxGenericTreeItem *gitem = (wxGenericTreeItem*) item.m_pItem;
1702
1703     // now scroll to the item
1704     int item_y = gitem->GetY();
1705
1706     int start_x = 0;
1707     int start_y = 0;
1708     GetViewStart( &start_x, &start_y );
1709     start_y *= PIXELS_PER_UNIT;
1710
1711     int client_h = 0;
1712     int client_w = 0;
1713     GetClientSize( &client_w, &client_h );
1714
1715     if (item_y < start_y+3)
1716     {
1717         // going down
1718         int x = 0;
1719         int y = 0;
1720         m_anchor->GetSize( x, y, this );
1721         y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1722         x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1723         int x_pos = GetScrollPos( wxHORIZONTAL );
1724         // Item should appear at top
1725         SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, item_y/PIXELS_PER_UNIT );
1726     }
1727     else if (item_y+GetLineHeight(gitem) > start_y+client_h)
1728     {
1729         // going up
1730         int x = 0;
1731         int y = 0;
1732         m_anchor->GetSize( x, y, this );
1733         y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1734         x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1735         item_y += PIXELS_PER_UNIT+2;
1736         int x_pos = GetScrollPos( wxHORIZONTAL );
1737         // Item should appear at bottom
1738         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 );
1739     }
1740 }
1741
1742 // FIXME: tree sorting functions are not reentrant and not MT-safe!
1743 static wxGenericTreeCtrl *s_treeBeingSorted = NULL;
1744
1745 static int LINKAGEMODE tree_ctrl_compare_func(wxGenericTreeItem **item1,
1746                                   wxGenericTreeItem **item2)
1747 {
1748     wxCHECK_MSG( s_treeBeingSorted, 0, wxT("bug in wxGenericTreeCtrl::SortChildren()") );
1749
1750     return s_treeBeingSorted->OnCompareItems(*item1, *item2);
1751 }
1752
1753 int wxGenericTreeCtrl::OnCompareItems(const wxTreeItemId& item1,
1754                                const wxTreeItemId& item2)
1755 {
1756     return wxStrcmp(GetItemText(item1), GetItemText(item2));
1757 }
1758
1759 void wxGenericTreeCtrl::SortChildren(const wxTreeItemId& itemId)
1760 {
1761     wxCHECK_RET( itemId.IsOk(), wxT("invalid tree item") );
1762
1763     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
1764
1765     wxCHECK_RET( !s_treeBeingSorted,
1766                  wxT("wxGenericTreeCtrl::SortChildren is not reentrant") );
1767
1768     wxArrayGenericTreeItems& children = item->GetChildren();
1769     if ( children.Count() > 1 )
1770     {
1771         m_dirty = TRUE;
1772
1773         s_treeBeingSorted = this;
1774         children.Sort(tree_ctrl_compare_func);
1775         s_treeBeingSorted = NULL;
1776     }
1777     //else: don't make the tree dirty as nothing changed
1778 }
1779
1780 wxImageList *wxGenericTreeCtrl::GetImageList() const
1781 {
1782     return m_imageListNormal;
1783 }
1784
1785 wxImageList *wxGenericTreeCtrl::GetButtonsImageList() const
1786 {
1787     return m_imageListButtons;
1788 }
1789
1790 wxImageList *wxGenericTreeCtrl::GetStateImageList() const
1791 {
1792     return m_imageListState;
1793 }
1794
1795 void wxGenericTreeCtrl::CalculateLineHeight()
1796 {
1797     wxClientDC dc(this);
1798     m_lineHeight = (int)(dc.GetCharHeight() + 4);
1799
1800     if ( m_imageListNormal )
1801     {
1802         // Calculate a m_lineHeight value from the normal Image sizes.
1803         // May be toggle off. Then wxGenericTreeCtrl will spread when
1804         // necessary (which might look ugly).
1805         int n = m_imageListNormal->GetImageCount();
1806         for (int i = 0; i < n ; i++)
1807         {
1808             int width = 0, height = 0;
1809             m_imageListNormal->GetSize(i, width, height);
1810             if (height > m_lineHeight) m_lineHeight = height;
1811         }
1812     }
1813
1814     if (m_imageListButtons)
1815     {
1816         // Calculate a m_lineHeight value from the Button image sizes.
1817         // May be toggle off. Then wxGenericTreeCtrl will spread when
1818         // necessary (which might look ugly).
1819         int n = m_imageListButtons->GetImageCount();
1820         for (int i = 0; i < n ; i++)
1821         {
1822             int width = 0, height = 0;
1823             m_imageListButtons->GetSize(i, width, height);
1824             if (height > m_lineHeight) m_lineHeight = height;
1825         }
1826     }
1827
1828     if (m_lineHeight < 30)
1829         m_lineHeight += 2;                 // at least 2 pixels
1830     else
1831         m_lineHeight += m_lineHeight/10;   // otherwise 10% extra spacing
1832 }
1833
1834 void wxGenericTreeCtrl::SetImageList(wxImageList *imageList)
1835 {
1836     if (m_ownsImageListNormal) delete m_imageListNormal;
1837     m_imageListNormal = imageList;
1838     m_ownsImageListNormal = FALSE;
1839     m_dirty = TRUE;
1840     CalculateLineHeight();
1841 }
1842
1843 void wxGenericTreeCtrl::SetStateImageList(wxImageList *imageList)
1844 {
1845     if (m_ownsImageListState) delete m_imageListState;
1846     m_imageListState = imageList;
1847     m_ownsImageListState = FALSE;
1848 }
1849
1850 void wxGenericTreeCtrl::SetButtonsImageList(wxImageList *imageList)
1851 {
1852     if (m_ownsImageListButtons) delete m_imageListButtons;
1853     m_imageListButtons = imageList;
1854     m_ownsImageListButtons = FALSE;
1855     m_dirty = TRUE;
1856     CalculateLineHeight();
1857 }
1858
1859 void wxGenericTreeCtrl::AssignImageList(wxImageList *imageList)
1860 {
1861     SetImageList(imageList);
1862     m_ownsImageListNormal = TRUE;
1863 }
1864
1865 void wxGenericTreeCtrl::AssignStateImageList(wxImageList *imageList)
1866 {
1867     SetStateImageList(imageList);
1868     m_ownsImageListState = TRUE;
1869 }
1870
1871 void wxGenericTreeCtrl::AssignButtonsImageList(wxImageList *imageList)
1872 {
1873     SetButtonsImageList(imageList);
1874     m_ownsImageListButtons = TRUE;
1875 }
1876
1877 // -----------------------------------------------------------------------------
1878 // helpers
1879 // -----------------------------------------------------------------------------
1880
1881 void wxGenericTreeCtrl::AdjustMyScrollbars()
1882 {
1883     if (m_anchor)
1884     {
1885         int x = 0, y = 0;
1886         m_anchor->GetSize( x, y, this );
1887         y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1888         x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
1889         int x_pos = GetScrollPos( wxHORIZONTAL );
1890         int y_pos = GetScrollPos( wxVERTICAL );
1891         SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, y_pos );
1892     }
1893     else
1894     {
1895         SetScrollbars( 0, 0, 0, 0 );
1896     }
1897 }
1898
1899 int wxGenericTreeCtrl::GetLineHeight(wxGenericTreeItem *item) const
1900 {
1901     if (GetWindowStyleFlag() & wxTR_HAS_VARIABLE_ROW_HEIGHT)
1902         return item->GetHeight();
1903     else
1904         return m_lineHeight;
1905 }
1906
1907 void wxGenericTreeCtrl::PaintItem(wxGenericTreeItem *item, wxDC& dc)
1908 {
1909     // TODO implement "state" icon on items
1910
1911     wxTreeItemAttr *attr = item->GetAttributes();
1912     if ( attr && attr->HasFont() )
1913         dc.SetFont(attr->GetFont());
1914     else if (item->IsBold())
1915         dc.SetFont(m_boldFont);
1916
1917     long text_w = 0, text_h = 0;
1918     dc.GetTextExtent( item->GetText(), &text_w, &text_h );
1919
1920     int image_h = 0, image_w = 0;
1921     int image = item->GetCurrentImage();
1922     if ( image != NO_IMAGE )
1923     {
1924         if ( m_imageListNormal )
1925         {
1926             m_imageListNormal->GetSize( image, image_w, image_h );
1927             image_w += 4;
1928         }
1929         else
1930         {
1931             image = NO_IMAGE;
1932         }
1933     }
1934
1935     int total_h = GetLineHeight(item);
1936
1937     if ( item->IsSelected() )
1938     {
1939         dc.SetBrush(*(m_hasFocus ? m_hilightBrush : m_hilightUnfocusedBrush));
1940     }
1941     else
1942     {
1943         wxColour colBg;
1944         if ( attr && attr->HasBackgroundColour() )
1945             colBg = attr->GetBackgroundColour();
1946         else
1947             colBg = m_backgroundColour;
1948         dc.SetBrush(wxBrush(colBg, wxSOLID));
1949     }
1950
1951     int offset = HasFlag(wxTR_ROW_LINES) ? 1 : 0;
1952
1953     if ( HasFlag(wxTR_FULL_ROW_HIGHLIGHT) )
1954     {
1955         int x, y, w, h;
1956
1957         DoGetPosition(&x, &y);
1958         DoGetSize(&w, &h);
1959         dc.DrawRectangle(x, item->GetY()+offset, w, total_h-offset);
1960     }
1961     else
1962     {
1963         if ( item->IsSelected() && image != NO_IMAGE )
1964         {
1965             // If it's selected, and there's an image, then we should
1966             // take care to leave the area under the image painted in the
1967             // background colour.
1968             dc.DrawRectangle( item->GetX() + image_w - 2, item->GetY()+offset,
1969                               item->GetWidth() - image_w + 2, total_h-offset );
1970         }
1971         else
1972         {
1973             dc.DrawRectangle( item->GetX()-2, item->GetY()+offset,
1974                               item->GetWidth()+2, total_h-offset );
1975         }
1976     }
1977
1978     if ( image != NO_IMAGE )
1979     {
1980         dc.SetClippingRegion( item->GetX(), item->GetY(), image_w-2, total_h );
1981         m_imageListNormal->Draw( image, dc,
1982                                  item->GetX(),
1983                                  item->GetY() +((total_h > image_h)?((total_h-image_h)/2):0),
1984                                  wxIMAGELIST_DRAW_TRANSPARENT );
1985         dc.DestroyClippingRegion();
1986     }
1987
1988     dc.SetBackgroundMode(wxTRANSPARENT);
1989     int extraH = (total_h > text_h) ? (total_h - text_h)/2 : 0;
1990     dc.DrawText( item->GetText(),
1991                  (wxCoord)(image_w + item->GetX()),
1992                  (wxCoord)(item->GetY() + extraH));
1993
1994     // restore normal font
1995     dc.SetFont( m_normalFont );
1996 }
1997
1998 // Now y stands for the top of the item, whereas it used to stand for middle !
1999 void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y )
2000 {
2001     int x = level*m_indent;
2002     if (!HasFlag(wxTR_HIDE_ROOT))
2003     {
2004         x += m_indent;
2005     }
2006     else if (level == 0)
2007     {
2008         // always expand hidden root
2009         int origY = y;
2010         wxArrayGenericTreeItems& children = item->GetChildren();
2011         int count = children.Count();
2012         if (count > 0)
2013         {
2014             int n = 0, oldY;
2015             do {
2016                 oldY = y;
2017                 PaintLevel(children[n], dc, 1, y);
2018             } while (++n < count);
2019
2020             if (!HasFlag(wxTR_NO_LINES) && HasFlag(wxTR_LINES_AT_ROOT) && count > 0)
2021             {
2022                 // draw line down to last child
2023                 origY += GetLineHeight(children[0])>>1;
2024                 oldY += GetLineHeight(children[n-1])>>1;
2025                 dc.DrawLine(3, origY, 3, oldY);
2026             }
2027         }
2028         return;
2029     }
2030
2031     item->SetX(x+m_spacing);
2032     item->SetY(y);
2033
2034     int h = GetLineHeight(item);
2035     int y_top = y;
2036     int y_mid = y_top + (h>>1);
2037     y += h;
2038
2039     int exposed_x = dc.LogicalToDeviceX(0);
2040     int exposed_y = dc.LogicalToDeviceY(y_top);
2041
2042     if (IsExposed(exposed_x, exposed_y, 10000, h))  // 10000 = very much
2043     {
2044         wxPen *pen =
2045 #ifndef __WXMAC__
2046             // don't draw rect outline if we already have the
2047             // background color under Mac
2048             (item->IsSelected() && m_hasFocus) ? wxBLACK_PEN :
2049 #endif // !__WXMAC__
2050             wxTRANSPARENT_PEN;
2051
2052         wxColour colText;
2053         if ( item->IsSelected() )
2054         {
2055             colText = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
2056         }
2057         else
2058         {
2059             wxTreeItemAttr *attr = item->GetAttributes();
2060             if (attr && attr->HasTextColour())
2061                 colText = attr->GetTextColour();
2062             else
2063                 colText = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOWTEXT);
2064         }
2065
2066         // prepare to draw
2067         dc.SetTextForeground(colText);
2068         dc.SetPen(*pen);
2069
2070         // draw
2071         PaintItem(item, dc);
2072
2073         if (HasFlag(wxTR_ROW_LINES))
2074         {
2075             // if the background colour is white, choose a
2076             // contrasting color for the lines
2077             dc.SetPen(*((GetBackgroundColour() == *wxWHITE)
2078                          ? wxMEDIUM_GREY_PEN : wxWHITE_PEN));
2079             dc.DrawLine(0, y_top, 10000, y_top);
2080             dc.DrawLine(0, y, 10000, y);
2081         }
2082
2083         // restore DC objects
2084         dc.SetBrush(*wxWHITE_BRUSH);
2085         dc.SetPen(m_dottedPen);
2086         dc.SetTextForeground(*wxBLACK);
2087
2088         if (item->HasPlus() && HasButtons())  // should the item show a button?
2089         {
2090             if (!HasFlag(wxTR_NO_LINES))
2091             {
2092                 if (x > (signed)m_indent)
2093                     dc.DrawLine(x - m_indent, y_mid, x - 5, y_mid);
2094                 else if (HasFlag(wxTR_LINES_AT_ROOT))
2095                     dc.DrawLine(3, y_mid, x - 5, y_mid);
2096                 dc.DrawLine(x + 5, y_mid, x + m_spacing, y_mid);
2097             }
2098
2099             if (m_imageListButtons != NULL)
2100             {
2101                 // draw the image button here
2102                 int image_h = 0, image_w = 0, image = wxTreeItemIcon_Normal;
2103                 if (item->IsExpanded()) image = wxTreeItemIcon_Expanded;
2104                 if (item->IsSelected())
2105                     image += wxTreeItemIcon_Selected - wxTreeItemIcon_Normal;
2106                 m_imageListButtons->GetSize(image, image_w, image_h);
2107                 int xx = x - (image_w>>1);
2108                 int yy = y_mid - (image_h>>1);
2109                 dc.SetClippingRegion(xx, yy, image_w, image_h);
2110                 m_imageListButtons->Draw(image, dc, xx, yy,
2111                                          wxIMAGELIST_DRAW_TRANSPARENT);
2112                 dc.DestroyClippingRegion();
2113             }
2114             else if (HasFlag(wxTR_TWIST_BUTTONS))
2115             {
2116                 // draw the twisty button here
2117
2118                 if (HasFlag(wxTR_AQUA_BUTTONS))
2119                 {
2120                     if (item->IsExpanded())
2121                         dc.DrawBitmap( *m_arrowDown, x-5, y_mid-6, TRUE );
2122                     else
2123                         dc.DrawBitmap( *m_arrowRight, x-5, y_mid-6, TRUE );
2124                 }
2125                 else
2126                 {
2127                     dc.SetBrush(*m_hilightBrush);
2128                     dc.SetPen(*wxBLACK_PEN);
2129                     wxPoint button[3];
2130
2131                     if (item->IsExpanded())
2132                     {
2133                         button[0].x = x-5;
2134                         button[0].y = y_mid-2;
2135                         button[1].x = x+5;
2136                         button[1].y = y_mid-2;
2137                         button[2].x = x;
2138                         button[2].y = y_mid+3;
2139                     }
2140                     else
2141                     {
2142                         button[0].y = y_mid-5;
2143                         button[0].x = x-2;
2144                         button[1].y = y_mid+5;
2145                         button[1].x = x-2;
2146                         button[2].y = y_mid;
2147                         button[2].x = x+3;
2148                     }
2149                     dc.DrawPolygon(3, button);
2150                     dc.SetPen(m_dottedPen);
2151                 }
2152             }
2153             else // if (HasFlag(wxTR_HAS_BUTTONS))
2154             {
2155                 // draw the plus sign here
2156                 dc.SetPen(*wxGREY_PEN);
2157                 dc.SetBrush(*wxWHITE_BRUSH);
2158                 dc.DrawRectangle(x-5, y_mid-4, 11, 9);
2159                 dc.SetPen(*wxBLACK_PEN);
2160                 dc.DrawLine(x-2, y_mid, x+3, y_mid);
2161                 if (!item->IsExpanded())
2162                     dc.DrawLine(x, y_mid-2, x, y_mid+3);
2163                 dc.SetPen(m_dottedPen);
2164             }
2165         }
2166         else if (!HasFlag(wxTR_NO_LINES))  // no button; maybe a line?
2167         {
2168             // draw the horizontal line here
2169             int x_start = x;
2170             if (x > (signed)m_indent)
2171                 x_start -= m_indent;
2172             else if (HasFlag(wxTR_LINES_AT_ROOT))
2173                 x_start = 3;
2174             dc.DrawLine(x_start, y_mid, x + m_spacing, y_mid);
2175         }
2176     }
2177
2178     if (item->IsExpanded())
2179     {
2180         wxArrayGenericTreeItems& children = item->GetChildren();
2181         int count = children.Count();
2182         if (count > 0)
2183         {
2184             int n = 0, oldY;
2185             ++level;
2186             do {
2187                 oldY = y;
2188                 PaintLevel(children[n], dc, level, y);
2189             } while (++n < count);
2190
2191             if (!HasFlag(wxTR_NO_LINES) && count > 0)
2192             {
2193                 // draw line down to last child
2194                 oldY += GetLineHeight(children[n-1])>>1;
2195                 if (HasButtons()) y_mid += 5;
2196                 dc.DrawLine(x, y_mid, x, oldY);
2197             }
2198         }
2199     }
2200 }
2201
2202 void wxGenericTreeCtrl::DrawDropEffect(wxGenericTreeItem *item)
2203 {
2204     if ( item )
2205     {
2206         if ( item->HasPlus() )
2207         {
2208             // it's a folder, indicate it by a border
2209             DrawBorder(item);
2210         }
2211         else
2212         {
2213             // draw a line under the drop target because the item will be
2214             // dropped there
2215             DrawLine(item, TRUE /* below */);
2216         }
2217
2218         SetCursor(wxCURSOR_BULLSEYE);
2219     }
2220     else
2221     {
2222         // can't drop here
2223         SetCursor(wxCURSOR_NO_ENTRY);
2224     }
2225 }
2226
2227 void wxGenericTreeCtrl::DrawBorder(const wxTreeItemId &item)
2228 {
2229     wxCHECK_RET( item.IsOk(), _T("invalid item in wxGenericTreeCtrl::DrawLine") );
2230
2231     wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
2232
2233     wxClientDC dc(this);
2234     PrepareDC( dc );
2235     dc.SetLogicalFunction(wxINVERT);
2236     dc.SetBrush(*wxTRANSPARENT_BRUSH);
2237
2238     int w = i->GetWidth() + 2;
2239     int h = GetLineHeight(i) + 2;
2240
2241     dc.DrawRectangle( i->GetX() - 1, i->GetY() - 1, w, h);
2242 }
2243
2244 void wxGenericTreeCtrl::DrawLine(const wxTreeItemId &item, bool below)
2245 {
2246     wxCHECK_RET( item.IsOk(), _T("invalid item in wxGenericTreeCtrl::DrawLine") );
2247
2248     wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
2249
2250     wxClientDC dc(this);
2251     PrepareDC( dc );
2252     dc.SetLogicalFunction(wxINVERT);
2253
2254     int x = i->GetX(),
2255         y = i->GetY();
2256     if ( below )
2257     {
2258         y += GetLineHeight(i) - 1;
2259     }
2260
2261     dc.DrawLine( x, y, x + i->GetWidth(), y);
2262 }
2263
2264 // -----------------------------------------------------------------------------
2265 // wxWindows callbacks
2266 // -----------------------------------------------------------------------------
2267
2268 void wxGenericTreeCtrl::OnPaint( wxPaintEvent &WXUNUSED(event) )
2269 {
2270     wxPaintDC dc(this);
2271     PrepareDC( dc );
2272
2273     if ( !m_anchor)
2274         return;
2275
2276     dc.SetFont( m_normalFont );
2277     dc.SetPen( m_dottedPen );
2278
2279     // this is now done dynamically
2280     //if(GetImageList() == NULL)
2281     // m_lineHeight = (int)(dc.GetCharHeight() + 4);
2282
2283     int y = 2;
2284     PaintLevel( m_anchor, dc, 0, y );
2285 }
2286
2287 void wxGenericTreeCtrl::OnSetFocus( wxFocusEvent &event )
2288 {
2289     m_hasFocus = TRUE;
2290
2291     RefreshSelected();
2292
2293     event.Skip();
2294 }
2295
2296 void wxGenericTreeCtrl::OnKillFocus( wxFocusEvent &event )
2297 {
2298     m_hasFocus = FALSE;
2299
2300     RefreshSelected();
2301
2302     event.Skip();
2303 }
2304
2305 void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
2306 {
2307     wxTreeEvent te( wxEVT_COMMAND_TREE_KEY_DOWN, GetId() );
2308     te.m_evtKey = event;
2309     te.SetEventObject( this );
2310     if ( GetEventHandler()->ProcessEvent( te ) )
2311     {
2312         // intercepted by the user code
2313         return;
2314     }
2315
2316     if ( (m_current == 0) || (m_key_current == 0) )
2317     {
2318         event.Skip();
2319         return;
2320     }
2321
2322     // how should the selection work for this event?
2323     bool is_multiple, extended_select, unselect_others;
2324     EventFlagsToSelType(GetWindowStyleFlag(),
2325                         event.ShiftDown(),
2326                         event.ControlDown(),
2327                         is_multiple, extended_select, unselect_others);
2328
2329     // + : Expand
2330     // - : Collaspe
2331     // * : Expand all/Collapse all
2332     // ' ' | return : activate
2333     // up    : go up (not last children!)
2334     // down  : go down
2335     // left  : go to parent
2336     // right : open if parent and go next
2337     // home  : go to root
2338     // end   : go to last item without opening parents
2339     switch (event.KeyCode())
2340     {
2341         case '+':
2342         case WXK_ADD:
2343             if (m_current->HasPlus() && !IsExpanded(m_current))
2344             {
2345                 Expand(m_current);
2346             }
2347             break;
2348
2349         case '*':
2350         case WXK_MULTIPLY:
2351             if ( !IsExpanded(m_current) )
2352             {
2353                 // expand all
2354                 ExpandAll(m_current);
2355                 break;
2356             }
2357             //else: fall through to Collapse() it
2358
2359         case '-':
2360         case WXK_SUBTRACT:
2361             if (IsExpanded(m_current))
2362             {
2363                 Collapse(m_current);
2364             }
2365             break;
2366
2367         case ' ':
2368         case WXK_RETURN:
2369             {
2370                 wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
2371                 event.m_item = (long) m_current;
2372                 event.SetEventObject( this );
2373                 GetEventHandler()->ProcessEvent( event );
2374             }
2375             break;
2376
2377             // up goes to the previous sibling or to the last
2378             // of its children if it's expanded
2379         case WXK_UP:
2380             {
2381                 wxTreeItemId prev = GetPrevSibling( m_key_current );
2382                 if (!prev)
2383                 {
2384                     prev = GetParent( m_key_current );
2385                     if ((prev == GetRootItem()) && HasFlag(wxTR_HIDE_ROOT))
2386                     {
2387                         break;  // don't go to root if it is hidden
2388                     }
2389                     if (prev)
2390                     {
2391                         long cookie = 0;
2392                         wxTreeItemId current = m_key_current;
2393                         // TODO: Huh?  If we get here, we'd better be the first child of our parent.  How else could it be?
2394                         if (current == GetFirstChild( prev, cookie ))
2395                         {
2396                             // otherwise we return to where we came from
2397                             SelectItem( prev, unselect_others, extended_select );
2398                             m_key_current= (wxGenericTreeItem*) prev.m_pItem;
2399                             EnsureVisible( prev );
2400                             break;
2401                         }
2402                     }
2403                 }
2404                 if (prev)
2405                 {
2406                     while ( IsExpanded(prev) && HasChildren(prev) )
2407                     {
2408                         wxTreeItemId child = GetLastChild(prev);
2409                         if ( child )
2410                         {
2411                             prev = child;
2412                         }
2413                     }
2414
2415                     SelectItem( prev, unselect_others, extended_select );
2416                     m_key_current=(wxGenericTreeItem*) prev.m_pItem;
2417                     EnsureVisible( prev );
2418                 }
2419             }
2420             break;
2421
2422             // left arrow goes to the parent
2423         case WXK_LEFT:
2424             {
2425                 wxTreeItemId prev = GetParent( m_current );
2426                 if ((prev == GetRootItem()) && HasFlag(wxTR_HIDE_ROOT))
2427                 {
2428                     // don't go to root if it is hidden
2429                     prev = GetPrevSibling( m_current );
2430                 }
2431                 if (prev)
2432                 {
2433                     EnsureVisible( prev );
2434                     SelectItem( prev, unselect_others, extended_select );
2435                 }
2436             }
2437             break;
2438
2439         case WXK_RIGHT:
2440             // this works the same as the down arrow except that we
2441             // also expand the item if it wasn't expanded yet
2442             Expand(m_current);
2443             // fall through
2444
2445         case WXK_DOWN:
2446             {
2447                 if (IsExpanded(m_key_current) && HasChildren(m_key_current))
2448                 {
2449                     long cookie = 0;
2450                     wxTreeItemId child = GetFirstChild( m_key_current, cookie );
2451                     SelectItem( child, unselect_others, extended_select );
2452                     m_key_current=(wxGenericTreeItem*) child.m_pItem;
2453                     EnsureVisible( child );
2454                 }
2455                 else
2456                 {
2457                     wxTreeItemId next = GetNextSibling( m_key_current );
2458                     if (!next)
2459                     {
2460                         wxTreeItemId current = m_key_current;
2461                         while (current && !next)
2462                         {
2463                             current = GetParent( current );
2464                             if (current) next = GetNextSibling( current );
2465                         }
2466                     }
2467                     if (next)
2468                     {
2469                         SelectItem( next, unselect_others, extended_select );
2470                         m_key_current=(wxGenericTreeItem*) next.m_pItem;
2471                         EnsureVisible( next );
2472                     }
2473                 }
2474             }
2475             break;
2476
2477             // <End> selects the last visible tree item
2478         case WXK_END:
2479             {
2480                 wxTreeItemId last = GetRootItem();
2481
2482                 while ( last.IsOk() && IsExpanded(last) )
2483                 {
2484                     wxTreeItemId lastChild = GetLastChild(last);
2485
2486                     // it may happen if the item was expanded but then all of
2487                     // its children have been deleted - so IsExpanded() returned
2488                     // TRUE, but GetLastChild() returned invalid item
2489                     if ( !lastChild )
2490                         break;
2491
2492                     last = lastChild;
2493                 }
2494
2495                 if ( last.IsOk() )
2496                 {
2497                     EnsureVisible( last );
2498                     SelectItem( last, unselect_others, extended_select );
2499                 }
2500             }
2501             break;
2502
2503             // <Home> selects the root item
2504         case WXK_HOME:
2505             {
2506                 wxTreeItemId prev = GetRootItem();
2507                 if (!prev) break;
2508                 if (HasFlag(wxTR_HIDE_ROOT))
2509                 {
2510                     long dummy;
2511                     prev = GetFirstChild(prev, dummy);
2512                     if (!prev) break;
2513                 }
2514                 EnsureVisible( prev );
2515                 SelectItem( prev, unselect_others, extended_select );
2516             }
2517             break;
2518
2519         default:
2520             event.Skip();
2521     }
2522 }
2523
2524 wxTreeItemId wxGenericTreeCtrl::HitTest(const wxPoint& point, int& flags)
2525 {
2526     // JACS: removed wxYieldIfNeeded() because it can cause the window
2527     // to be deleted from under us if a close window event is pending
2528
2529     int w, h;
2530     GetSize(&w, &h);
2531     flags=0;
2532     if (point.x<0) flags |= wxTREE_HITTEST_TOLEFT;
2533     if (point.x>w) flags |= wxTREE_HITTEST_TORIGHT;
2534     if (point.y<0) flags |= wxTREE_HITTEST_ABOVE;
2535     if (point.y>h) flags |= wxTREE_HITTEST_BELOW;
2536     if (flags) return wxTreeItemId();
2537
2538     if (m_anchor == NULL)
2539     {
2540         flags = wxTREE_HITTEST_NOWHERE;
2541         return wxTreeItemId();
2542     }
2543
2544     wxClientDC dc(this);
2545     PrepareDC(dc);
2546     wxCoord x = dc.DeviceToLogicalX( point.x );
2547     wxCoord y = dc.DeviceToLogicalY( point.y );
2548     wxGenericTreeItem *hit =  m_anchor->HitTest(wxPoint(x, y),
2549                                                 this,
2550                                                 flags,
2551                                                 0 );
2552     if (hit == NULL)
2553     {
2554         flags = wxTREE_HITTEST_NOWHERE;
2555         return wxTreeItemId();
2556     }
2557     return hit;
2558 }
2559
2560 // get the bounding rectangle of the item (or of its label only)
2561 bool wxGenericTreeCtrl::GetBoundingRect(const wxTreeItemId& item,
2562                          wxRect& rect,
2563                          bool WXUNUSED(textOnly)) const
2564 {
2565     wxCHECK_MSG( item.IsOk(), FALSE, _T("invalid item in wxGenericTreeCtrl::GetBoundingRect") );
2566
2567     wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
2568
2569     int startX, startY;
2570     GetViewStart(& startX, & startY);
2571
2572     rect.x = i->GetX() - startX*PIXELS_PER_UNIT;
2573     rect.y = i->GetY() - startY*PIXELS_PER_UNIT;
2574     rect.width = i->GetWidth();
2575     //rect.height = i->GetHeight();
2576     rect.height = GetLineHeight(i);
2577
2578     return TRUE;
2579 }
2580
2581 /* **** */
2582
2583 void wxGenericTreeCtrl::Edit( const wxTreeItemId& item )
2584 {
2585     if (!item.IsOk()) return;
2586
2587     m_currentEdit = (wxGenericTreeItem*) item.m_pItem;
2588
2589     wxTreeEvent te( wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, GetId() );
2590     te.m_item = (long) m_currentEdit;
2591     te.SetEventObject( this );
2592     GetEventHandler()->ProcessEvent( te );
2593
2594     if (!te.IsAllowed()) return;
2595
2596     // We have to call this here because the label in
2597     // question might just have been added and no screen
2598     // update taken place.
2599     if (m_dirty) wxYieldIfNeeded();
2600
2601     wxString s = m_currentEdit->GetText();
2602     int x = m_currentEdit->GetX();
2603     int y = m_currentEdit->GetY();
2604     int w = m_currentEdit->GetWidth();
2605     int h = m_currentEdit->GetHeight();
2606
2607     int image_h = 0;
2608     int image_w = 0;
2609
2610     int image = m_currentEdit->GetCurrentImage();
2611     if ( image != NO_IMAGE )
2612     {
2613         if ( m_imageListNormal )
2614         {
2615             m_imageListNormal->GetSize( image, image_w, image_h );
2616             image_w += 4;
2617         }
2618         else
2619         {
2620             wxFAIL_MSG(_T("you must create an image list to use images!"));
2621         }
2622     }
2623     x += image_w;
2624     w -= image_w + 4; // I don't know why +4 is needed
2625
2626     wxClientDC dc(this);
2627     PrepareDC( dc );
2628     x = dc.LogicalToDeviceX( x );
2629     y = dc.LogicalToDeviceY( y );
2630
2631     wxTreeTextCtrl *text = new wxTreeTextCtrl(this, -1,
2632                                               &m_renameAccept,
2633                                               &m_renameRes,
2634                                               this,
2635                                               s,
2636                                               wxPoint(x-4,y-4),
2637                                               wxSize(w+11,h+8));
2638     text->SetFocus();
2639 }
2640
2641 void wxGenericTreeCtrl::OnRenameTimer()
2642 {
2643     Edit( m_current );
2644 }
2645
2646 void wxGenericTreeCtrl::OnRenameAccept()
2647 {
2648     // TODO if the validator fails this causes a crash
2649     wxTreeEvent le( wxEVT_COMMAND_TREE_END_LABEL_EDIT, GetId() );
2650     le.m_item = (long) m_currentEdit;
2651     le.SetEventObject( this );
2652     le.m_label = m_renameRes;
2653     GetEventHandler()->ProcessEvent( le );
2654
2655     if (!le.IsAllowed()) return;
2656
2657     SetItemText( m_currentEdit, m_renameRes );
2658 }
2659
2660 void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
2661 {
2662     if ( !m_anchor ) return;
2663
2664     // we process left mouse up event (enables in-place edit), right down
2665     // (pass to the user code), left dbl click (activate item) and
2666     // dragging/moving events for items drag-and-drop
2667     if ( !(event.LeftDown() ||
2668            event.LeftUp() ||
2669            event.RightDown() ||
2670            event.LeftDClick() ||
2671            event.Dragging() ||
2672            ((event.Moving() || event.RightUp()) && m_isDragging)) )
2673     {
2674         event.Skip();
2675
2676         return;
2677     }
2678
2679     wxClientDC dc(this);
2680     PrepareDC(dc);
2681     wxCoord x = dc.DeviceToLogicalX( event.GetX() );
2682     wxCoord y = dc.DeviceToLogicalY( event.GetY() );
2683
2684     int flags = 0;
2685     wxGenericTreeItem *item = m_anchor->HitTest( wxPoint(x,y),
2686                                                  this,
2687                                                  flags,
2688                                                  0 );
2689
2690     if ( event.Dragging() && !m_isDragging )
2691     {
2692         if (m_dragCount == 0)
2693             m_dragStart = wxPoint(x,y);
2694
2695         m_dragCount++;
2696
2697         if (m_dragCount != 3)
2698         {
2699             // wait until user drags a bit further...
2700             return;
2701         }
2702
2703         wxEventType command = event.RightIsDown()
2704                               ? wxEVT_COMMAND_TREE_BEGIN_RDRAG
2705                               : wxEVT_COMMAND_TREE_BEGIN_DRAG;
2706
2707         wxTreeEvent nevent( command, GetId() );
2708         nevent.m_item = (long) m_current;
2709         nevent.SetEventObject(this);
2710
2711         // by default the dragging is not supported, the user code must
2712         // explicitly allow the event for it to take place
2713         nevent.Veto();
2714
2715         if ( GetEventHandler()->ProcessEvent(nevent) && nevent.IsAllowed() )
2716         {
2717             // we're going to drag this item
2718             m_isDragging = TRUE;
2719
2720             // remember the old cursor because we will change it while
2721             // dragging
2722             m_oldCursor = m_cursor;
2723
2724             // in a single selection control, hide the selection temporarily
2725             if ( !(GetWindowStyleFlag() & wxTR_MULTIPLE) )
2726             {
2727                 m_oldSelection = (wxGenericTreeItem*) GetSelection().m_pItem;
2728
2729                 if ( m_oldSelection )
2730                 {
2731                     m_oldSelection->SetHilight(FALSE);
2732                     RefreshLine(m_oldSelection);
2733                 }
2734             }
2735
2736             CaptureMouse();
2737         }
2738     }
2739     else if ( event.Moving() )
2740     {
2741         if ( item != m_dropTarget )
2742         {
2743             // unhighlight the previous drop target
2744             DrawDropEffect(m_dropTarget);
2745
2746             m_dropTarget = item;
2747
2748             // highlight the current drop target if any
2749             DrawDropEffect(m_dropTarget);
2750
2751             wxYieldIfNeeded();
2752         }
2753     }
2754     else if ( (event.LeftUp() || event.RightUp()) && m_isDragging )
2755     {
2756         // erase the highlighting
2757         DrawDropEffect(m_dropTarget);
2758
2759         if ( m_oldSelection )
2760         {
2761             m_oldSelection->SetHilight(TRUE);
2762             RefreshLine(m_oldSelection);
2763             m_oldSelection = (wxGenericTreeItem *)NULL;
2764         }
2765
2766         // generate the drag end event
2767         wxTreeEvent event(wxEVT_COMMAND_TREE_END_DRAG, GetId());
2768
2769         event.m_item = (long) item;
2770         event.m_pointDrag = wxPoint(x, y);
2771         event.SetEventObject(this);
2772
2773         (void)GetEventHandler()->ProcessEvent(event);
2774
2775         m_isDragging = FALSE;
2776         m_dropTarget = (wxGenericTreeItem *)NULL;
2777
2778         ReleaseMouse();
2779
2780         SetCursor(m_oldCursor);
2781
2782         wxYieldIfNeeded();
2783     }
2784     else
2785     {
2786         // here we process only the messages which happen on tree items
2787
2788         m_dragCount = 0;
2789
2790         if (item == NULL) return;  /* we hit the blank area */
2791
2792         if ( event.RightDown() )
2793         {
2794             wxTreeEvent nevent(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK, GetId());
2795             nevent.m_item = (long) item;
2796             CalcScrolledPosition(x, y,
2797                                  &nevent.m_pointDrag.x,
2798                                  &nevent.m_pointDrag.y);
2799             nevent.SetEventObject(this);
2800             GetEventHandler()->ProcessEvent(nevent);
2801         }
2802         else if ( event.LeftUp() )
2803         {
2804             if ( m_lastOnSame )
2805             {
2806                 if ( (item == m_current) &&
2807                      (flags & wxTREE_HITTEST_ONITEMLABEL) &&
2808                      HasFlag(wxTR_EDIT_LABELS) )
2809                 {
2810                     if ( m_renameTimer->IsRunning() )
2811                         m_renameTimer->Stop();
2812
2813                     m_renameTimer->Start( 100, TRUE );
2814                 }
2815
2816                 m_lastOnSame = FALSE;
2817             }
2818         }
2819         else // !RightDown() && !LeftUp() ==> LeftDown() || LeftDClick()
2820         {
2821             if ( event.LeftDown() )
2822             {
2823                 m_lastOnSame = item == m_current;
2824             }
2825
2826             if ( flags & wxTREE_HITTEST_ONITEMBUTTON )
2827             {
2828                 // only toggle the item for a single click, double click on
2829                 // the button doesn't do anything (it toggles the item twice)
2830                 if ( event.LeftDown() )
2831                 {
2832                     Toggle( item );
2833                 }
2834
2835                 // don't select the item if the button was clicked
2836                 return;
2837             }
2838
2839             // how should the selection work for this event?
2840             bool is_multiple, extended_select, unselect_others;
2841             EventFlagsToSelType(GetWindowStyleFlag(),
2842                                 event.ShiftDown(),
2843                                 event.ControlDown(),
2844                                 is_multiple, extended_select, unselect_others);
2845
2846             SelectItem(item, unselect_others, extended_select);
2847
2848             // For some reason, Windows isn't recognizing a left double-click,
2849             // so we need to simulate it here.  Allow 200 milliseconds for now.
2850             if ( event.LeftDClick() )
2851             {
2852                 // double clicking should not start editing the item label
2853                 m_renameTimer->Stop();
2854                 m_lastOnSame = FALSE;
2855
2856                 // send activate event first
2857                 wxTreeEvent nevent( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
2858                 nevent.m_item = (long) item;
2859                 CalcScrolledPosition(x, y,
2860                                      &nevent.m_pointDrag.x,
2861                                      &nevent.m_pointDrag.y);
2862                 nevent.SetEventObject( this );
2863                 if ( !GetEventHandler()->ProcessEvent( nevent ) )
2864                 {
2865                     // if the user code didn't process the activate event,
2866                     // handle it ourselves by toggling the item when it is
2867                     // double clicked
2868                     if ( item->HasPlus() )
2869                     {
2870                         Toggle(item);
2871                     }
2872                 }
2873             }
2874         }
2875     }
2876 }
2877
2878 void wxGenericTreeCtrl::OnIdle( wxIdleEvent &WXUNUSED(event) )
2879 {
2880     /* after all changes have been done to the tree control,
2881      * we actually redraw the tree when everything is over */
2882
2883     if (!m_dirty) return;
2884
2885     m_dirty = FALSE;
2886
2887     CalculatePositions();
2888     Refresh();
2889     AdjustMyScrollbars();
2890 }
2891
2892 void wxGenericTreeCtrl::CalculateSize( wxGenericTreeItem *item, wxDC &dc )
2893 {
2894     wxCoord text_w = 0;
2895     wxCoord text_h = 0;
2896
2897     if (item->IsBold())
2898         dc.SetFont(m_boldFont);
2899
2900     dc.GetTextExtent( item->GetText(), &text_w, &text_h );
2901     text_h+=2;
2902
2903     // restore normal font
2904     dc.SetFont( m_normalFont );
2905
2906     int image_h = 0;
2907     int image_w = 0;
2908     int image = item->GetCurrentImage();
2909     if ( image != NO_IMAGE )
2910     {
2911         if ( m_imageListNormal )
2912         {
2913             m_imageListNormal->GetSize( image, image_w, image_h );
2914             image_w += 4;
2915         }
2916     }
2917
2918     int total_h = (image_h > text_h) ? image_h : text_h;
2919
2920     if (total_h < 30)
2921         total_h += 2;            // at least 2 pixels
2922     else
2923         total_h += total_h/10;   // otherwise 10% extra spacing
2924
2925     item->SetHeight(total_h);
2926     if (total_h>m_lineHeight)
2927         m_lineHeight=total_h;
2928
2929     item->SetWidth(image_w+text_w+2);
2930 }
2931
2932 // -----------------------------------------------------------------------------
2933 // for developper : y is now the top of the level
2934 // not the middle of it !
2935 void wxGenericTreeCtrl::CalculateLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y )
2936 {
2937     int x = level*m_indent;
2938     if (!HasFlag(wxTR_HIDE_ROOT))
2939     {
2940         x += m_indent;
2941     }
2942     else if (level == 0)
2943     {
2944         // a hidden root is not evaluated, but its
2945         // children are always calculated
2946         goto Recurse;
2947     }
2948
2949     CalculateSize( item, dc );
2950
2951     // set its position
2952     item->SetX( x+m_spacing );
2953     item->SetY( y );
2954     y += GetLineHeight(item);
2955
2956     if ( !item->IsExpanded() )
2957     {
2958         // we don't need to calculate collapsed branches
2959         return;
2960     }
2961
2962   Recurse:
2963     wxArrayGenericTreeItems& children = item->GetChildren();
2964     size_t n, count = children.Count();
2965     ++level;
2966     for (n = 0; n < count; ++n )
2967         CalculateLevel( children[n], dc, level, y );  // recurse
2968 }
2969
2970 void wxGenericTreeCtrl::CalculatePositions()
2971 {
2972     if ( !m_anchor ) return;
2973
2974     wxClientDC dc(this);
2975     PrepareDC( dc );
2976
2977     dc.SetFont( m_normalFont );
2978
2979     dc.SetPen( m_dottedPen );
2980     //if(GetImageList() == NULL)
2981     // m_lineHeight = (int)(dc.GetCharHeight() + 4);
2982
2983     int y = 2;
2984     CalculateLevel( m_anchor, dc, 0, y ); // start recursion
2985 }
2986
2987 void wxGenericTreeCtrl::RefreshSubtree(wxGenericTreeItem *item)
2988 {
2989     if (m_dirty) return;
2990
2991     wxClientDC dc(this);
2992     PrepareDC(dc);
2993
2994     int cw = 0;
2995     int ch = 0;
2996     GetClientSize( &cw, &ch );
2997
2998     wxRect rect;
2999     rect.x = dc.LogicalToDeviceX( 0 );
3000     rect.width = cw;
3001     rect.y = dc.LogicalToDeviceY( item->GetY() );
3002     rect.height = ch;
3003
3004     Refresh( TRUE, &rect );
3005
3006     AdjustMyScrollbars();
3007 }
3008
3009 void wxGenericTreeCtrl::RefreshLine( wxGenericTreeItem *item )
3010 {
3011     if (m_dirty) return;
3012
3013     wxClientDC dc(this);
3014     PrepareDC( dc );
3015
3016     int cw = 0;
3017     int ch = 0;
3018     GetClientSize( &cw, &ch );
3019
3020     wxRect rect;
3021     rect.x = dc.LogicalToDeviceX( 0 );
3022     rect.y = dc.LogicalToDeviceY( item->GetY() );
3023     rect.width = cw;
3024     rect.height = GetLineHeight(item); //dc.GetCharHeight() + 6;
3025
3026     Refresh( TRUE, &rect );
3027 }
3028
3029 void wxGenericTreeCtrl::RefreshSelected()
3030 {
3031     // TODO: this is awfully inefficient, we should keep the list of all
3032     //       selected items internally, should be much faster
3033     if ( m_anchor )
3034         RefreshSelectedUnder(m_anchor);
3035 }
3036
3037 void wxGenericTreeCtrl::RefreshSelectedUnder(wxGenericTreeItem *item)
3038 {
3039     if ( item->IsSelected() )
3040         RefreshLine(item);
3041
3042     const wxArrayGenericTreeItems& children = item->GetChildren();
3043     size_t count = children.GetCount();
3044     for ( size_t n = 0; n < count; n++ )
3045     {
3046         RefreshSelectedUnder(children[n]);
3047     }
3048 }
3049
3050 // ----------------------------------------------------------------------------
3051 // changing colours: we need to refresh the tree control
3052 // ----------------------------------------------------------------------------
3053
3054 bool wxGenericTreeCtrl::SetBackgroundColour(const wxColour& colour)
3055 {
3056     if ( !wxWindow::SetBackgroundColour(colour) )
3057         return FALSE;
3058
3059     Refresh();
3060
3061     return TRUE;
3062 }
3063
3064 bool wxGenericTreeCtrl::SetForegroundColour(const wxColour& colour)
3065 {
3066     if ( !wxWindow::SetForegroundColour(colour) )
3067         return FALSE;
3068
3069     Refresh();
3070
3071     return TRUE;
3072 }
3073
3074 #endif // wxUSE_TREECTRL