src/generic/treectlg.cpp

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