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