new file added

[wxWidgets.git] / src / generic / treectlg.cpp
diff --git a/src/generic/treectlg.cpp b/src/generic/treectlg.cpp

index 833404dd9f71f8786c68238ddac93092aa551443..b11fd4b44960459d66effc35b0a57b817b805b0d 100644 (file)
--- a/src/generic/treectlg.cpp
+++ b/src/generic/treectlg.cpp
@@ -1,11 +1,11 @@
  /////////////////////////////////////////////////////////////////////////////
  /////////////////////////////////////////////////////////////////////////////
-// Name:        treectlg.cpp
+// Name:        src/generic/treectlg.cpp
  // Purpose:     generic tree control implementation
  // Author:      Robert Roebling
  // Created:     01/02/97
  // Modified:    22/10/98 - almost total rewrite, simpler interface (VZ)
  // Id:          $Id$
  // Purpose:     generic tree control implementation
  // Author:      Robert Roebling
  // Created:     01/02/97
  // Modified:    22/10/98 - almost total rewrite, simpler interface (VZ)
  // Id:          $Id$
-// Copyright:   (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
+// Copyright:   (c) 1998 Robert Roebling and Julian Smart
  // Licence:     wxWindows licence
  /////////////////////////////////////////////////////////////////////////////
  
  // Licence:     wxWindows licence
  /////////////////////////////////////////////////////////////////////////////
  
@@ -17,10 +17,6 @@
  // headers
  // -----------------------------------------------------------------------------
  
  // headers
  // -----------------------------------------------------------------------------
  
-#ifdef __GNUG__
-  #pragma implementation "treectlg.h"
-#endif
-
  // For compilers that support precompilation, includes "wx.h".
  #include "wx/wxprec.h"
  
  // For compilers that support precompilation, includes "wx.h".
  #include "wx/wxprec.h"
  
@@ -30,22 +26,32 @@
  
  #if wxUSE_TREECTRL
  
  
  #if wxUSE_TREECTRL
  
-#include "wx/treebase.h"
+#include "wx/treectrl.h"
+
+#ifndef WX_PRECOMP
+    #include "wx/dcclient.h"
+    #include "wx/timer.h"
+    #include "wx/settings.h"
+    #include "wx/listbox.h"
+    #include "wx/textctrl.h"
+#endif
+
  #include "wx/generic/treectlg.h"
  #include "wx/generic/treectlg.h"
-#include "wx/timer.h"
-#include "wx/textctrl.h"
  #include "wx/imaglist.h"
  #include "wx/imaglist.h"
-#include "wx/settings.h"
-#include "wx/dcclient.h"
+
+#include "wx/renderer.h"
+
+#ifdef __WXMAC__
+    #include "wx/osx/private.h"
+#endif
  
  // -----------------------------------------------------------------------------
  // array types
  // -----------------------------------------------------------------------------
  
  
  // -----------------------------------------------------------------------------
  // array types
  // -----------------------------------------------------------------------------
  
-class WXDLLEXPORT wxGenericTreeItem;
+class WXDLLIMPEXP_FWD_CORE wxGenericTreeItem;
  
  
-WX_DEFINE_EXPORTED_ARRAY(wxGenericTreeItem *, wxArrayGenericTreeItems);
-//WX_DEFINE_OBJARRAY(wxArrayTreeItemIds);
+WX_DEFINE_ARRAY_PTR(wxGenericTreeItem *, wxArrayGenericTreeItems);
  
  // ----------------------------------------------------------------------------
  // constants
  
  // ----------------------------------------------------------------------------
  // constants
@@ -53,55 +59,13 @@ WX_DEFINE_EXPORTED_ARRAY(wxGenericTreeItem *, wxArrayGenericTreeItems);
  
  static const int NO_IMAGE = -1;
  
  
  static const int NO_IMAGE = -1;
  
-#define PIXELS_PER_UNIT 10
-
-// ----------------------------------------------------------------------------
-// Aqua arrows
-// ----------------------------------------------------------------------------
+static const int PIXELS_PER_UNIT = 10;
  
  
-/* XPM */
-static const char *aqua_arrow_right[] = {
-/* columns rows colors chars-per-pixel */
-"13 11 4 1",
-"  c None",
-"b c #C0C0C0",
-"c c #707070",
-"d c #A0A0A0",
-/* pixels */
-"    b        ",
-"    ddb      ",
-"    cccdb    ",
-"    cccccd   ",
-"    ccccccdb ",
-"    ccccccccd",
-"    ccccccdb ",
-"    cccccb   ",
-"    cccdb    ",
-"    ddb      ",
-"    b        "
-};
+// the margin between the item state image and the item normal image
+static const int MARGIN_BETWEEN_STATE_AND_IMAGE = 2;
  
  
-/* XPM */
-static const char *aqua_arrow_down[] = {
-/* columns rows colors chars-per-pixel */
-"13 11 4 1",
-"  c None",
-"b c #C0C0C0",
-"c c #707070",
-"d c #A0A0A0",
-/* pixels */
-"             ",
-"             ",
-" bdcccccccdb ",
-"  dcccccccd  ",
-"  bcccccccb  ",
-"   dcccccd   ",
-"   bcccccb   ",
-"    bcccd    ",
-"     dcd     ",
-"     bcb     ",
-"      d      "
-};
+// the margin between the item image and the item text
+static const int MARGIN_BETWEEN_IMAGE_AND_TEXT = 4;
  
  // -----------------------------------------------------------------------------
  // private classes
  
  // -----------------------------------------------------------------------------
  // private classes
@@ -111,42 +75,64 @@ static const char *aqua_arrow_down[] = {
  class WXDLLEXPORT wxTreeRenameTimer: public wxTimer
  {
  public:
  class WXDLLEXPORT wxTreeRenameTimer: public wxTimer
  {
  public:
+    // start editing the current item after half a second (if the mouse hasn't
+    // been clicked/moved)
+    enum { DELAY = 500 };
+
      wxTreeRenameTimer( wxGenericTreeCtrl *owner );
  
      wxTreeRenameTimer( wxGenericTreeCtrl *owner );
  
-    void Notify();
+    virtual void Notify();
  
  private:
  
  private:
-    wxGenericTreeCtrl   *m_owner;
+    wxGenericTreeCtrl *m_owner;
+
+    wxDECLARE_NO_COPY_CLASS(wxTreeRenameTimer);
  };
  
  // control used for in-place edit
  class WXDLLEXPORT wxTreeTextCtrl: public wxTextCtrl
  {
  public:
  };
  
  // control used for in-place edit
  class WXDLLEXPORT wxTreeTextCtrl: public wxTextCtrl
  {
  public:
-    wxTreeTextCtrl( wxWindow *parent,
-                    const wxWindowID id,
-                    bool *accept,
-                    wxString *res,
-                    wxGenericTreeCtrl *owner,
-                    const wxString &value = wxEmptyString,
-                    const wxPoint &pos = wxDefaultPosition,
-                    const wxSize &size = wxDefaultSize,
-                    int style = wxSIMPLE_BORDER,
-                    const wxValidator& validator = wxDefaultValidator,
-                    const wxString &name = wxTextCtrlNameStr );
+    wxTreeTextCtrl(wxGenericTreeCtrl *owner, wxGenericTreeItem *item);
  
  
+    void EndEdit( bool discardChanges );
+
+    const wxGenericTreeItem* item() const { return m_itemEdited; }
+
+protected:
      void OnChar( wxKeyEvent &event );
      void OnKeyUp( wxKeyEvent &event );
      void OnKillFocus( wxFocusEvent &event );
  
      void OnChar( wxKeyEvent &event );
      void OnKeyUp( wxKeyEvent &event );
      void OnKillFocus( wxFocusEvent &event );
  
+    bool AcceptChanges();
+    void Finish( bool setfocus );
+
  private:
  private:
-    bool               *m_accept;
-    wxString           *m_res;
      wxGenericTreeCtrl  *m_owner;
      wxGenericTreeCtrl  *m_owner;
+    wxGenericTreeItem  *m_itemEdited;
      wxString            m_startValue;
      wxString            m_startValue;
-    bool                m_finished;
+    bool                m_aboutToFinish;
  
      DECLARE_EVENT_TABLE()
  
      DECLARE_EVENT_TABLE()
+    wxDECLARE_NO_COPY_CLASS(wxTreeTextCtrl);
+};
+
+// timer used to clear wxGenericTreeCtrl::m_findPrefix if no key was pressed
+// for a sufficiently long time
+class WXDLLEXPORT wxTreeFindTimer : public wxTimer
+{
+public:
+    // reset the current prefix after half a second of inactivity
+    enum { DELAY = 500 };
+
+    wxTreeFindTimer( wxGenericTreeCtrl *owner ) { m_owner = owner; }
+
+    virtual void Notify() { m_owner->m_findPrefix.clear(); }
+
+private:
+    wxGenericTreeCtrl *m_owner;
+
+    wxDECLARE_NO_COPY_CLASS(wxTreeFindTimer);
  };
  
  // a tree item
  };
  
  // a tree item
@@ -154,7 +140,13 @@ class WXDLLEXPORT wxGenericTreeItem
  {
  public:
      // ctors & dtor
  {
  public:
      // ctors & dtor
-    wxGenericTreeItem() { m_data = NULL; }
+    wxGenericTreeItem()
+    {
+        m_data = NULL;
+        m_widthText =
+        m_heightText = -1;
+    }
+
      wxGenericTreeItem( wxGenericTreeItem *parent,
                         const wxString& text,
                         int image,
      wxGenericTreeItem( wxGenericTreeItem *parent,
                         const wxString& text,
                         int image,
@@ -170,18 +162,36 @@ public:
      int GetImage(wxTreeItemIcon which = wxTreeItemIcon_Normal) const
          { return m_images[which]; }
      wxTreeItemData *GetData() const { return m_data; }
      int GetImage(wxTreeItemIcon which = wxTreeItemIcon_Normal) const
          { return m_images[which]; }
      wxTreeItemData *GetData() const { return m_data; }
+    int GetState() const { return m_state; }
  
      // returns the current image for the item (depending on its
      // selected/expanded/whatever state)
      int GetCurrentImage() const;
  
  
      // returns the current image for the item (depending on its
      // selected/expanded/whatever state)
      int GetCurrentImage() const;
  
-    void SetText( const wxString &text );
-    void SetImage(int image, wxTreeItemIcon which) { m_images[which] = image; }
+    void SetText(const wxString& text)
+    {
+        m_text = text;
+
+        ResetTextSize();
+    }
+
+    void SetImage(int image, wxTreeItemIcon which)
+    {
+        m_images[which] = image;
+        m_width = 0;
+    }
+
      void SetData(wxTreeItemData *data) { m_data = data; }
      void SetData(wxTreeItemData *data) { m_data = data; }
+    void SetState(int state) { m_state = state; m_width = 0; }
  
  
-    void SetHasPlus(bool has = TRUE) { m_hasPlus = has; }
+    void SetHasPlus(bool has = true) { m_hasPlus = has; }
+
+    void SetBold(bool bold)
+    {
+        m_isBold = bold;
  
  
-    void SetBold(bool bold) { m_isBold = bold; }
+        ResetTextSize();
+    }
  
      int GetX() const { return m_x; }
      int GetY() const { return m_y; }
  
      int GetX() const { return m_x; }
      int GetY() const { return m_y; }
@@ -189,39 +199,80 @@ public:
      void SetX(int x) { m_x = x; }
      void SetY(int y) { m_y = y; }
  
      void SetX(int x) { m_x = x; }
      void SetY(int y) { m_y = y; }
  
-    int  GetHeight() const { return m_height; }
-    int  GetWidth()  const { return m_width; }
+    int GetHeight() const { return m_height; }
+    int GetWidth() const { return m_width; }
+
+    int GetTextHeight() const
+    {
+        wxASSERT_MSG( m_heightText != -1, "must call CalculateSize() first" );
+
+        return m_heightText;
+    }
+
+    int GetTextWidth() const
+    {
+        wxASSERT_MSG( m_widthText != -1, "must call CalculateSize() first" );
  
  
-    void SetHeight(int h) { m_height = h; }
-    void SetWidth(int w) { m_width = w; }
+        return m_widthText;
+    }
  
      wxGenericTreeItem *GetParent() const { return m_parent; }
  
  
      wxGenericTreeItem *GetParent() const { return m_parent; }
  
+    // sets the items font for the specified DC if it uses any special font or
+    // simply returns false otherwise
+    bool SetFont(wxGenericTreeCtrl *control, wxDC& dc) const
+    {
+        wxFont font;
+
+        wxTreeItemAttr * const attr = GetAttributes();
+        if ( attr && attr->HasFont() )
+            font = attr->GetFont();
+        else if ( IsBold() )
+            font = control->m_boldFont;
+        else
+            return false;
+
+        dc.SetFont(font);
+        return true;
+    }
+
      // operations
      // operations
-        // deletes all children notifying the treectrl about it if !NULL
-        // pointer given
-    void DeleteChildren(wxGenericTreeCtrl *tree = NULL);
+
+    // deletes all children notifying the treectrl about it
+    void DeleteChildren(wxGenericTreeCtrl *tree);
  
      // get count of all children (and grand children if 'recursively')
  
      // get count of all children (and grand children if 'recursively')
-    size_t GetChildrenCount(bool recursively = TRUE) const;
+    size_t GetChildrenCount(bool recursively = true) const;
  
      void Insert(wxGenericTreeItem *child, size_t index)
  
      void Insert(wxGenericTreeItem *child, size_t index)
-    { m_children.Insert(child, index); }
+        { m_children.Insert(child, index); }
+
+    // calculate and cache the item size using either the provided DC (which is
+    // supposed to have wxGenericTreeCtrl::m_normalFont selected into it!) or a
+    // wxClientDC on the control window
+    void CalculateSize(wxGenericTreeCtrl *control, wxDC& dc)
+        { DoCalculateSize(control, dc, true /* dc uses normal font */); }
+    void CalculateSize(wxGenericTreeCtrl *control);
  
      void GetSize( int &x, int &y, const wxGenericTreeCtrl* );
  
  
      void GetSize( int &x, int &y, const wxGenericTreeCtrl* );
  
+    void ResetSize() { m_width = 0; }
+    void ResetTextSize() { m_width = 0; m_widthText = -1; }
+    void RecursiveResetSize();
+    void RecursiveResetTextSize();
+
          // return the item at given position (or NULL if no item), onButton is
          // return the item at given position (or NULL if no item), onButton is
-        // TRUE if the point belongs to the item's button, otherwise it lies
-        // on the button's label
+        // true if the point belongs to the item's button, otherwise it lies
+        // on the item's label
      wxGenericTreeItem *HitTest( const wxPoint& point,
                                  const wxGenericTreeCtrl *,
                                  int &flags,
                                  int level );
  
      wxGenericTreeItem *HitTest( const wxPoint& point,
                                  const wxGenericTreeCtrl *,
                                  int &flags,
                                  int level );
  
-    void Expand() { m_isCollapsed = FALSE; }
-    void Collapse() { m_isCollapsed = TRUE; }
+    void Expand() { m_isCollapsed = false; }
+    void Collapse() { m_isCollapsed = true; }
  
  
-    void SetHilight( bool set = TRUE ) { m_hasHilight = set; }
+    void SetHilight( bool set = true ) { m_hasHilight = set; }
  
      // status inquiries
      bool HasChildren() const { return !m_children.IsEmpty(); }
  
      // status inquiries
      bool HasChildren() const { return !m_children.IsEmpty(); }
@@ -239,7 +290,7 @@ public:
          if ( !m_attr )
          {
              m_attr = new wxTreeItemAttr;
          if ( !m_attr )
          {
              m_attr = new wxTreeItemAttr;
-            m_ownsAttr = TRUE;
+            m_ownsAttr = true;
          }
          return *m_attr;
      }
          }
          return *m_attr;
      }
@@ -248,23 +299,40 @@ public:
      {
          if ( m_ownsAttr ) delete m_attr;
          m_attr = attr;
      {
          if ( m_ownsAttr ) delete m_attr;
          m_attr = attr;
-        m_ownsAttr = FALSE;
+        m_ownsAttr = false;
+        m_width = 0;
+        m_widthText = -1;
      }
          // set them and delete when done
      void AssignAttributes(wxTreeItemAttr *attr)
      {
          SetAttributes(attr);
      }
          // set them and delete when done
      void AssignAttributes(wxTreeItemAttr *attr)
      {
          SetAttributes(attr);
-        m_ownsAttr = TRUE;
+        m_ownsAttr = true;
+        m_width = 0;
+        m_widthText = -1;
      }
  
  private:
      }
  
  private:
+    // calculate the size of this item, i.e. set m_width, m_height and
+    // m_widthText and m_heightText properly
+    //
+    // if dcUsesNormalFont is true, the current dc font must be the normal tree
+    // control font
+    void DoCalculateSize(wxGenericTreeCtrl *control,
+                         wxDC& dc,
+                         bool dcUsesNormalFont);
+
      // since there can be very many of these, we save size by chosing
      // the smallest representation for the elements and by ordering
      // the members to avoid padding.
      wxString            m_text;         // label to be rendered for item
      // since there can be very many of these, we save size by chosing
      // the smallest representation for the elements and by ordering
      // the members to avoid padding.
      wxString            m_text;         // label to be rendered for item
+    int                 m_widthText;
+    int                 m_heightText;
  
      wxTreeItemData     *m_data;         // user-provided data
  
  
      wxTreeItemData     *m_data;         // user-provided data
  
+    int                 m_state;        // item state
+
      wxArrayGenericTreeItems m_children; // list of children
      wxGenericTreeItem  *m_parent;       // parent of this item
  
      wxArrayGenericTreeItems m_children; // list of children
      wxGenericTreeItem  *m_parent;       // parent of this item
  
@@ -272,20 +340,22 @@ private:
  
      // tree ctrl images for the normal, selected, expanded and
      // expanded+selected states
  
      // tree ctrl images for the normal, selected, expanded and
      // expanded+selected states
-    short               m_images[wxTreeItemIcon_Max];
+    int                 m_images[wxTreeItemIcon_Max];
  
      wxCoord             m_x;            // (virtual) offset from top
  
      wxCoord             m_x;            // (virtual) offset from top
-    short               m_y;            // (virtual) offset from left
-    short               m_width;        // width of this item
-    unsigned char       m_height;       // height of this item
+    wxCoord             m_y;            // (virtual) offset from left
+    int                 m_width;        // width of this item
+    int                 m_height;       // height of this item
  
      // use bitfields to save size
  
      // use bitfields to save size
-    int                 m_isCollapsed :1;
-    int                 m_hasHilight  :1; // same as focused
-    int                 m_hasPlus     :1; // used for item which doesn't have
+    unsigned int        m_isCollapsed :1;
+    unsigned int        m_hasHilight  :1; // same as focused
+    unsigned int        m_hasPlus     :1; // used for item which doesn't have
                                            // children but has a [+] button
                                            // children but has a [+] button
-    int                 m_isBold      :1; // render the label in bold font
-    int                 m_ownsAttr    :1; // delete attribute when done
+    unsigned int        m_isBold      :1; // render the label in bold font
+    unsigned int        m_ownsAttr    :1; // delete attribute when done
+
+    wxDECLARE_NO_COPY_CLASS(wxGenericTreeItem);
  };
  
  // =============================================================================
  };
  
  // =============================================================================
@@ -310,6 +380,24 @@ static void EventFlagsToSelType(long style,
      unselect_others = !(extended_select || (ctrlDown && is_multiple));
  }
  
      unselect_others = !(extended_select || (ctrlDown && is_multiple));
  }
  
+// check if the given item is under another one
+static bool
+IsDescendantOf(const wxGenericTreeItem *parent, const wxGenericTreeItem *item)
+{
+    while ( item )
+    {
+        if ( item == parent )
+        {
+            // item is a descendant of parent
+            return true;
+        }
+
+        item = item->GetParent();
+    }
+
+    return false;
+}
+
  // -----------------------------------------------------------------------------
  // wxTreeRenameTimer (internal)
  // -----------------------------------------------------------------------------
  // -----------------------------------------------------------------------------
  // wxTreeRenameTimer (internal)
  // -----------------------------------------------------------------------------
@@ -334,99 +422,148 @@ BEGIN_EVENT_TABLE(wxTreeTextCtrl,wxTextCtrl)
      EVT_KILL_FOCUS     (wxTreeTextCtrl::OnKillFocus)
  END_EVENT_TABLE()
  
      EVT_KILL_FOCUS     (wxTreeTextCtrl::OnKillFocus)
  END_EVENT_TABLE()
  
-wxTreeTextCtrl::wxTreeTextCtrl( wxWindow *parent,
-                                const wxWindowID id,
-                                bool *accept,
-                                wxString *res,
-                                wxGenericTreeCtrl *owner,
-                                const wxString &value,
-                                const wxPoint &pos,
-                                const wxSize &size,
-                                int style,
-                                const wxValidator& validator,
-                                const wxString &name )
-    : wxTextCtrl( parent, id, value, pos, size, style, validator, name )
-{
-    m_res = res;
-    m_accept = accept;
+wxTreeTextCtrl::wxTreeTextCtrl(wxGenericTreeCtrl *owner,
+                               wxGenericTreeItem *item)
+              : m_itemEdited(item), m_startValue(item->GetText())
+{
      m_owner = owner;
      m_owner = owner;
-    (*m_accept) = FALSE;
-    (*m_res) = wxEmptyString;
-    m_startValue = value;
-    m_finished = FALSE;
+    m_aboutToFinish = false;
+
+    wxRect rect;
+    m_owner->GetBoundingRect(m_itemEdited, rect, true);
+
+    // corrects position and size for better appearance
+#ifdef __WXMSW__
+    rect.x -= 5;
+    rect.width += 10;
+#elif defined(__WXGTK__)
+    rect.x -= 5;
+    rect.y -= 2;
+    rect.width  += 8;
+    rect.height += 4;
+#elif defined(wxOSX_USE_CARBON) && wxOSX_USE_CARBON
+    int bestHeight = GetBestSize().y - 8;
+    if ( rect.height > bestHeight )
+    {
+        int diff = rect.height - bestHeight;
+        rect.height -= diff;
+        rect.y += diff / 2;
+    }
+#endif // platforms
+
+    (void)Create(m_owner, wxID_ANY, m_startValue,
+                 rect.GetPosition(), rect.GetSize());
+
+    SetSelection(-1, -1);
  }
  
  }
  
-void wxTreeTextCtrl::OnChar( wxKeyEvent &event )
+void wxTreeTextCtrl::EndEdit(bool discardChanges)
  {
  {
-    if (event.m_keyCode == WXK_RETURN)
+    m_aboutToFinish = true;
+
+    if ( discardChanges )
+    {
+        m_owner->OnRenameCancelled(m_itemEdited);
+
+        Finish( true );
+    }
+    else
      {
      {
-        (*m_accept) = TRUE;
-        (*m_res) = GetValue();
+        // Notify the owner about the changes
+        AcceptChanges();
  
  
-        if ((*m_res) != m_startValue)
-            m_owner->OnRenameAccept();
+        // Even if vetoed, close the control (consistent with MSW)
+        Finish( true );
+    }
+}
  
  
-        if (!wxPendingDelete.Member(this))
-            wxPendingDelete.Append(this);
+bool wxTreeTextCtrl::AcceptChanges()
+{
+    const wxString value = GetValue();
  
  
-        m_finished = TRUE;
-        m_owner->SetFocus(); // This doesn't work. TODO.
+    if ( value == m_startValue )
+    {
+        // nothing changed, always accept
+        // when an item remains unchanged, the owner
+        // needs to be notified that the user decided
+        // not to change the tree item label, and that
+        // the edit has been cancelled
  
  
-        return;
+        m_owner->OnRenameCancelled(m_itemEdited);
+        return true;
      }
      }
-    if (event.m_keyCode == WXK_ESCAPE)
+
+    if ( !m_owner->OnRenameAccept(m_itemEdited, value) )
      {
      {
-        (*m_accept) = FALSE;
-        (*m_res) = "";
+        // vetoed by the user
+        return false;
+    }
  
  
-        if (!wxPendingDelete.Member(this))
-            wxPendingDelete.Append(this);
+    // accepted, do rename the item
+    m_owner->SetItemText(m_itemEdited, value);
  
  
-        m_finished = TRUE;
-        m_owner->SetFocus(); // This doesn't work. TODO.
+    return true;
+}
  
  
-        return;
+void wxTreeTextCtrl::Finish( bool setfocus )
+{
+    m_owner->ResetTextControl();
+
+    wxPendingDelete.Append(this);
+
+    if (setfocus)
+        m_owner->SetFocus();
+}
+
+void wxTreeTextCtrl::OnChar( wxKeyEvent &event )
+{
+    switch ( event.m_keyCode )
+    {
+        case WXK_RETURN:
+            EndEdit( false );
+            break;
+
+        case WXK_ESCAPE:
+            EndEdit( true );
+            break;
+
+        default:
+            event.Skip();
      }
      }
-    event.Skip();
  }
  
  void wxTreeTextCtrl::OnKeyUp( wxKeyEvent &event )
  {
  }
  
  void wxTreeTextCtrl::OnKeyUp( wxKeyEvent &event )
  {
-    if (m_finished)
+    if ( !m_aboutToFinish )
      {
      {
-        event.Skip();
-        return;
+        // auto-grow the textctrl:
+        wxSize parentSize = m_owner->GetSize();
+        wxPoint myPos = GetPosition();
+        wxSize mySize = GetSize();
+        int sx, sy;
+        GetTextExtent(GetValue() + wxT("M"), &sx, &sy);
+        if (myPos.x + sx > parentSize.x)
+            sx = parentSize.x - myPos.x;
+        if (mySize.x > sx)
+            sx = mySize.x;
+        SetSize(sx, wxDefaultCoord);
      }
  
      }
  
-    // auto-grow the textctrl:
-    wxSize parentSize = m_owner->GetSize();
-    wxPoint myPos = GetPosition();
-    wxSize mySize = GetSize();
-    int sx, sy;
-    GetTextExtent(GetValue() + _T("M"), &sx, &sy);
-    if (myPos.x + sx > parentSize.x) sx = parentSize.x - myPos.x;
-    if (mySize.x > sx) sx = mySize.x;
-    SetSize(sx, -1);
-
      event.Skip();
  }
  
  void wxTreeTextCtrl::OnKillFocus( wxFocusEvent &event )
  {
      event.Skip();
  }
  
  void wxTreeTextCtrl::OnKillFocus( wxFocusEvent &event )
  {
-    if (m_finished)
+    if ( !m_aboutToFinish )
      {
      {
-        event.Skip();
-        return;
-    }
+        if ( !AcceptChanges() )
+            m_owner->OnRenameCancelled( m_itemEdited );
  
  
-    if (!wxPendingDelete.Member(this))
-        wxPendingDelete.Append(this);
-
-    (*m_accept) = TRUE;
-    (*m_res) = GetValue();
+        Finish( false );
+    }
  
  
-    if ((*m_res) != m_startValue)
-        m_owner->OnRenameAccept();
+    // We should let the native text control handle focus, too.
+    event.Skip();
  }
  
  // -----------------------------------------------------------------------------
  }
  
  // -----------------------------------------------------------------------------
@@ -445,21 +582,25 @@ wxGenericTreeItem::wxGenericTreeItem(wxGenericTreeItem *parent,
      m_images[wxTreeItemIcon_SelectedExpanded] = NO_IMAGE;
  
      m_data = data;
      m_images[wxTreeItemIcon_SelectedExpanded] = NO_IMAGE;
  
      m_data = data;
+    m_state = wxTREE_ITEMSTATE_NONE;
      m_x = m_y = 0;
  
      m_x = m_y = 0;
  
-    m_isCollapsed = TRUE;
-    m_hasHilight = FALSE;
-    m_hasPlus = FALSE;
-    m_isBold = FALSE;
+    m_isCollapsed = true;
+    m_hasHilight = false;
+    m_hasPlus = false;
+    m_isBold = false;
  
      m_parent = parent;
  
  
      m_parent = parent;
  
-    m_attr = (wxTreeItemAttr *)NULL;
-    m_ownsAttr = FALSE;
+    m_attr = NULL;
+    m_ownsAttr = false;
  
      // We don't know the height here yet.
      m_width = 0;
      m_height = 0;
  
      // We don't know the height here yet.
      m_width = 0;
      m_height = 0;
+
+    m_widthText = -1;
+    m_heightText = -1;
  }
  
  wxGenericTreeItem::~wxGenericTreeItem()
  }
  
  wxGenericTreeItem::~wxGenericTreeItem()
@@ -469,33 +610,29 @@ wxGenericTreeItem::~wxGenericTreeItem()
      if (m_ownsAttr) delete m_attr;
  
      wxASSERT_MSG( m_children.IsEmpty(),
      if (m_ownsAttr) delete m_attr;
  
      wxASSERT_MSG( m_children.IsEmpty(),
-                  wxT("please call DeleteChildren() before deleting the item") );
+                  "must call DeleteChildren() before deleting the item" );
  }
  
  void wxGenericTreeItem::DeleteChildren(wxGenericTreeCtrl *tree)
  {
  }
  
  void wxGenericTreeItem::DeleteChildren(wxGenericTreeCtrl *tree)
  {
-    size_t count = m_children.Count();
+    size_t count = m_children.GetCount();
      for ( size_t n = 0; n < count; n++ )
      {
          wxGenericTreeItem *child = m_children[n];
      for ( size_t n = 0; n < count; n++ )
      {
          wxGenericTreeItem *child = m_children[n];
-        if (tree)
-            tree->SendDeleteEvent(child);
+        tree->SendDeleteEvent(child);
  
          child->DeleteChildren(tree);
  
          child->DeleteChildren(tree);
+        if ( child == tree->m_select_me )
+            tree->m_select_me = NULL;
          delete child;
      }
  
      m_children.Empty();
  }
  
          delete child;
      }
  
      m_children.Empty();
  }
  
-void wxGenericTreeItem::SetText( const wxString &text )
-{
-    m_text = text;
-}
-
  size_t wxGenericTreeItem::GetChildrenCount(bool recursively) const
  {
  size_t wxGenericTreeItem::GetChildrenCount(bool recursively) const
  {
-    size_t count = m_children.Count();
+    size_t count = m_children.GetCount();
      if ( !recursively )
          return count;
  
      if ( !recursively )
          return count;
  
@@ -518,7 +655,7 @@ void wxGenericTreeItem::GetSize( int &x, int &y,
  
      if (IsExpanded())
      {
  
      if (IsExpanded())
      {
-        size_t count = m_children.Count();
+        size_t count = m_children.GetCount();
          for ( size_t n = 0; n < count; ++n )
          {
              m_children[n]->GetSize( x, y, theButton );
          for ( size_t n = 0; n < count; ++n )
          {
              m_children[n]->GetSize( x, y, theButton );
@@ -544,11 +681,19 @@ wxGenericTreeItem *wxGenericTreeItem::HitTest(const wxPoint& point,
              else
                  flags |= wxTREE_HITTEST_ONITEMLOWERPART;
  
              else
                  flags |= wxTREE_HITTEST_ONITEMLOWERPART;
  
-            // 5 is the size of the plus sign
              int xCross = m_x - theCtrl->GetSpacing();
              int xCross = m_x - theCtrl->GetSpacing();
-            if ((point.x > xCross-5) && (point.x < xCross+5) &&
-                (point.y > y_mid-5) && (point.y < y_mid+5) &&
+#ifdef __WXMAC__
+            // according to the drawing code the triangels are drawn
+            // at -4 , -4  from the position up to +10/+10 max
+            if ((point.x > xCross-4) && (point.x < xCross+10) &&
+                (point.y > y_mid-4) && (point.y < y_mid+10) &&
+                HasPlus() && theCtrl->HasButtons() )
+#else
+            // 5 is the size of the plus sign
+            if ((point.x > xCross-6) && (point.x < xCross+6) &&
+                (point.y > y_mid-6) && (point.y < y_mid+6) &&
                  HasPlus() && theCtrl->HasButtons() )
                  HasPlus() && theCtrl->HasButtons() )
+#endif
              {
                  flags |= wxTREE_HITTEST_ONITEMBUTTON;
                  return this;
              {
                  flags |= wxTREE_HITTEST_ONITEMBUTTON;
                  return this;
@@ -561,10 +706,29 @@ wxGenericTreeItem *wxGenericTreeItem::HitTest(const wxPoint& point,
  
                  // assuming every image (normal and selected) has the same size!
                  if ( (GetImage() != NO_IMAGE) && theCtrl->m_imageListNormal )
  
                  // assuming every image (normal and selected) has the same size!
                  if ( (GetImage() != NO_IMAGE) && theCtrl->m_imageListNormal )
+                {
                      theCtrl->m_imageListNormal->GetSize(GetImage(),
                                                          image_w, image_h);
                      theCtrl->m_imageListNormal->GetSize(GetImage(),
                                                          image_w, image_h);
+                }
  
  
-                if ((image_w != -1) && (point.x <= m_x + image_w + 1))
+                int state_w = -1;
+                int state_h;
+
+                if ( (GetState() != wxTREE_ITEMSTATE_NONE) &&
+                        theCtrl->m_imageListState )
+                {
+                    theCtrl->m_imageListState->GetSize(GetState(),
+                                                       state_w, state_h);
+                }
+
+                if ((state_w != -1) && (point.x <= m_x + state_w + 1))
+                    flags |= wxTREE_HITTEST_ONITEMSTATEICON;
+                else if ((image_w != -1) &&
+                         (point.x <= m_x +
+                            (state_w != -1 ? state_w +
+                                                MARGIN_BETWEEN_STATE_AND_IMAGE
+                                           : 0)
+                                            + image_w + 1))
                      flags |= wxTREE_HITTEST_ONITEMICON;
                  else
                      flags |= wxTREE_HITTEST_ONITEMLABEL;
                      flags |= wxTREE_HITTEST_ONITEMICON;
                  else
                      flags |= wxTREE_HITTEST_ONITEMLABEL;
@@ -581,11 +745,11 @@ wxGenericTreeItem *wxGenericTreeItem::HitTest(const wxPoint& point,
          }
  
          // if children are expanded, fall through to evaluate them
          }
  
          // if children are expanded, fall through to evaluate them
-        if (m_isCollapsed) return (wxGenericTreeItem*) NULL;
+        if (m_isCollapsed) return NULL;
      }
  
      // evaluate children
      }
  
      // evaluate children
-    size_t count = m_children.Count();
+    size_t count = m_children.GetCount();
      for ( size_t n = 0; n < count; n++ )
      {
          wxGenericTreeItem *res = m_children[n]->HitTest( point,
      for ( size_t n = 0; n < count; n++ )
      {
          wxGenericTreeItem *res = m_children[n]->HitTest( point,
@@ -596,7 +760,7 @@ wxGenericTreeItem *wxGenericTreeItem::HitTest(const wxPoint& point,
              return res;
      }
  
              return res;
      }
  
-    return (wxGenericTreeItem*) NULL;
+    return NULL;
  }
  
  int wxGenericTreeItem::GetCurrentImage() const
  }
  
  int wxGenericTreeItem::GetCurrentImage() const
@@ -629,39 +793,134 @@ int wxGenericTreeItem::GetCurrentImage() const
      return image;
  }
  
      return image;
  }
  
+void wxGenericTreeItem::CalculateSize(wxGenericTreeCtrl* control)
+{
+    // check if we need to do anything before creating the DC
+    if ( m_width != 0 )
+        return;
+
+    wxClientDC dc(control);
+    DoCalculateSize(control, dc, false /* normal font not used */);
+}
+
+void
+wxGenericTreeItem::DoCalculateSize(wxGenericTreeCtrl* control,
+                                   wxDC& dc,
+                                   bool dcUsesNormalFont)
+{
+    if ( m_width != 0 ) // Size known, nothing to do
+        return;
+
+    if ( m_widthText == -1 )
+    {
+        bool fontChanged;
+        if ( SetFont(control, dc) )
+        {
+            fontChanged = true;
+        }
+        else // we have no special font
+        {
+           if ( !dcUsesNormalFont )
+           {
+               // but we do need to ensure that the normal font is used: notice
+               // that this doesn't count as changing the font as we don't need
+               // to restore it
+               dc.SetFont(control->m_normalFont);
+           }
+
+           fontChanged = false;
+        }
+
+        dc.GetTextExtent( GetText(), &m_widthText, &m_heightText );
+
+        // restore normal font if the DC used it previously and we changed it
+        if ( fontChanged )
+             dc.SetFont(control->m_normalFont);
+    }
+
+    int text_h = m_heightText + 2;
+
+    int image_h = 0, image_w = 0;
+    int image = GetCurrentImage();
+    if ( image != NO_IMAGE && control->m_imageListNormal )
+    {
+        control->m_imageListNormal->GetSize(image, image_w, image_h);
+        image_w += MARGIN_BETWEEN_IMAGE_AND_TEXT;
+    }
+
+    int state_h = 0, state_w = 0;
+    int state = GetState();
+    if ( state != wxTREE_ITEMSTATE_NONE && control->m_imageListState )
+    {
+        control->m_imageListState->GetSize(state, state_w, state_h);
+        if ( image_w != 0 )
+            state_w += MARGIN_BETWEEN_STATE_AND_IMAGE;
+        else
+            state_w += MARGIN_BETWEEN_IMAGE_AND_TEXT;
+    }
+
+    int img_h = wxMax(state_h, image_h);
+    m_height = wxMax(img_h, text_h);
+
+    if (m_height < 30)
+        m_height += 2;            // at least 2 pixels
+    else
+        m_height += m_height / 10;   // otherwise 10% extra spacing
+
+    if (m_height > control->m_lineHeight)
+        control->m_lineHeight = m_height;
+
+    m_width = state_w + image_w + m_widthText + 2;
+}
+
+void wxGenericTreeItem::RecursiveResetSize()
+{
+    m_width = 0;
+
+    const size_t count = m_children.Count();
+    for (size_t i = 0; i < count; i++ )
+        m_children[i]->RecursiveResetSize();
+}
+
+void wxGenericTreeItem::RecursiveResetTextSize()
+{
+    m_width = 0;
+    m_widthText = -1;
+
+    const size_t count = m_children.Count();
+    for (size_t i = 0; i < count; i++ )
+        m_children[i]->RecursiveResetTextSize();
+}
+
  // -----------------------------------------------------------------------------
  // wxGenericTreeCtrl implementation
  // -----------------------------------------------------------------------------
  
  // -----------------------------------------------------------------------------
  // wxGenericTreeCtrl implementation
  // -----------------------------------------------------------------------------
  
-IMPLEMENT_DYNAMIC_CLASS(wxGenericTreeCtrl, wxScrolledWindow)
+IMPLEMENT_DYNAMIC_CLASS(wxGenericTreeCtrl, wxControl)
  
  
-BEGIN_EVENT_TABLE(wxGenericTreeCtrl,wxScrolledWindow)
+BEGIN_EVENT_TABLE(wxGenericTreeCtrl, wxTreeCtrlBase)
      EVT_PAINT          (wxGenericTreeCtrl::OnPaint)
      EVT_PAINT          (wxGenericTreeCtrl::OnPaint)
+    EVT_SIZE           (wxGenericTreeCtrl::OnSize)
      EVT_MOUSE_EVENTS   (wxGenericTreeCtrl::OnMouse)
      EVT_MOUSE_EVENTS   (wxGenericTreeCtrl::OnMouse)
+    EVT_KEY_DOWN       (wxGenericTreeCtrl::OnKeyDown)
      EVT_CHAR           (wxGenericTreeCtrl::OnChar)
      EVT_SET_FOCUS      (wxGenericTreeCtrl::OnSetFocus)
      EVT_KILL_FOCUS     (wxGenericTreeCtrl::OnKillFocus)
      EVT_CHAR           (wxGenericTreeCtrl::OnChar)
      EVT_SET_FOCUS      (wxGenericTreeCtrl::OnSetFocus)
      EVT_KILL_FOCUS     (wxGenericTreeCtrl::OnKillFocus)
-    EVT_IDLE           (wxGenericTreeCtrl::OnIdle)
+    EVT_TREE_ITEM_GETTOOLTIP(wxID_ANY, wxGenericTreeCtrl::OnGetToolTip)
  END_EVENT_TABLE()
  
  END_EVENT_TABLE()
  
-#if !defined(__WXMSW__) || defined(__WIN16__) || defined(__WXUNIVERSAL__)
-/*
- * wxTreeCtrl has to be a real class or we have problems with
- * the run-time information.
- */
-
-IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxGenericTreeCtrl)
-#endif
-
  // -----------------------------------------------------------------------------
  // construction/destruction
  // -----------------------------------------------------------------------------
  
  void wxGenericTreeCtrl::Init()
  {
  // -----------------------------------------------------------------------------
  // construction/destruction
  // -----------------------------------------------------------------------------
  
  void wxGenericTreeCtrl::Init()
  {
-    m_current = m_key_current = m_anchor = (wxGenericTreeItem *) NULL;
-    m_hasFocus = FALSE;
-    m_dirty = FALSE;
+    m_current =
+    m_key_current =
+    m_anchor =
+    m_select_me = NULL;
+    m_hasFocus = false;
+    m_dirty = false;
  
      m_lineHeight = 10;
      m_indent = 15;
  
      m_lineHeight = 10;
      m_indent = 15;
@@ -673,7 +932,7 @@ void wxGenericTreeCtrl::Init()
                              (
                                  wxSYS_COLOUR_HIGHLIGHT
                              ),
                              (
                                  wxSYS_COLOUR_HIGHLIGHT
                              ),
-                            wxSOLID
+                            wxBRUSHSTYLE_SOLID
                           );
  
      m_hilightUnfocusedBrush = new wxBrush
                           );
  
      m_hilightUnfocusedBrush = new wxBrush
@@ -682,27 +941,35 @@ void wxGenericTreeCtrl::Init()
                                   (
                                       wxSYS_COLOUR_BTNSHADOW
                                   ),
                                   (
                                       wxSYS_COLOUR_BTNSHADOW
                                   ),
-                                 wxSOLID
+                                 wxBRUSHSTYLE_SOLID
                                );
  
                                );
  
-    m_imageListNormal = m_imageListButtons =
-    m_imageListState = (wxImageList *) NULL;
-    m_ownsImageListNormal = m_ownsImageListButtons =
-    m_ownsImageListState = FALSE;
+    m_imageListButtons = NULL;
+    m_ownsImageListButtons = false;
  
      m_dragCount = 0;
  
      m_dragCount = 0;
-    m_isDragging = FALSE;
-    m_dropTarget = m_oldSelection = (wxGenericTreeItem *)NULL;
+    m_isDragging = false;
+    m_dropTarget = m_oldSelection = NULL;
+    m_underMouse = NULL;
+    m_textCtrl = NULL;
+
+    m_renameTimer = NULL;
+
+    m_findTimer = NULL;
+
+    m_dropEffectAboveItem = false;
  
  
-    m_renameTimer = new wxTreeRenameTimer( this );
-    m_lastOnSame = FALSE;
+    m_dndEffect = NoEffect;
+    m_dndEffectItem = NULL;
  
  
+    m_lastOnSame = false;
+
+#if defined( __WXMAC__ )
+    m_normalFont = wxFont(wxOSX_SYSTEM_FONT_VIEWS);
+#else
      m_normalFont = wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT );
      m_normalFont = wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT );
-    m_boldFont = wxFont( m_normalFont.GetPointSize(),
-                         m_normalFont.GetFamily(),
-                         m_normalFont.GetStyle(),
-                         wxBOLD,
-                         m_normalFont.GetUnderlined());
+#endif
+    m_boldFont = m_normalFont.Bold();
  }
  
  bool wxGenericTreeCtrl::Create(wxWindow *parent,
  }
  
  bool wxGenericTreeCtrl::Create(wxWindow *parent,
@@ -710,36 +977,30 @@ bool wxGenericTreeCtrl::Create(wxWindow *parent,
                                 const wxPoint& pos,
                                 const wxSize& size,
                                 long style,
                                 const wxPoint& pos,
                                 const wxSize& size,
                                 long style,
-                               const wxValidator &validator,
+                               const wxValidator& validator,
                                 const wxString& name )
  {
  #ifdef __WXMAC__
                                 const wxString& name )
  {
  #ifdef __WXMAC__
-    int major,minor;
-    wxGetOsVersion( &major, &minor );
+    int major, minor;
+    wxGetOsVersion(&major, &minor);
  
  
-    if (style & wxTR_HAS_BUTTONS) style |= wxTR_MAC_BUTTONS;
-    if (style & wxTR_HAS_BUTTONS) style &= ~wxTR_HAS_BUTTONS;
-    style &= ~wxTR_LINES_AT_ROOT;
-    style |= wxTR_NO_LINES;
      if (major < 10)
          style |= wxTR_ROW_LINES;
      if (major < 10)
          style |= wxTR_ROW_LINES;
-    if (major >= 10)
-        style |= wxTR_AQUA_BUTTONS;
-#endif
  
  
-    if (style & wxTR_AQUA_BUTTONS)
-    {
-        m_arrowRight = new wxBitmap( aqua_arrow_right );
-        m_arrowDown = new wxBitmap( aqua_arrow_down );
-    }
-    else
-    {
-        m_arrowRight = NULL;
-        m_arrowDown = NULL;
-    }
+    if (style & wxTR_HAS_BUTTONS)
+        style |= wxTR_NO_LINES;
+#endif // __WXMAC__
  
  
-    wxScrolledWindow::Create( parent, id, pos, size,
-                              style|wxHSCROLL|wxVSCROLL, name );
+#ifdef __WXGTK20__
+    if (style & wxTR_HAS_BUTTONS)
+        style |= wxTR_NO_LINES;
+#endif
+
+    if ( !wxControl::Create( parent, id, pos, size,
+                             style|wxHSCROLL|wxVSCROLL|wxWANTS_CHARS,
+                             validator,
+                             name ) )
+        return false;
  
      // If the tree display has no buttons, but does have
      // connecting lines, we can use a narrower layout.
  
      // If the tree display has no buttons, but does have
      // connecting lines, we can use a narrower layout.
@@ -750,17 +1011,24 @@ bool wxGenericTreeCtrl::Create(wxWindow *parent,
          m_spacing = 10;
      }
  
          m_spacing = 10;
      }
  
-#if wxUSE_VALIDATORS
-    SetValidator( validator );
-#endif
+    wxVisualAttributes attr = GetDefaultAttributes();
+    SetOwnForegroundColour( attr.colFg );
+    SetOwnBackgroundColour( attr.colBg );
+    if (!m_hasFont)
+        SetOwnFont(attr.font);
  
  
-    SetForegroundColour( wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT) );
-    SetBackgroundColour( wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOX) );
+    // this is a misnomer: it's called "dotted pen" but uses (default) wxSOLID
+    // style because we apparently get performance problems when using dotted
+    // pen for drawing in some ports -- but under MSW it seems to work fine
+#ifdef __WXMSW__
+    m_dottedPen = wxPen(*wxLIGHT_GREY, 0, wxPENSTYLE_DOT);
+#else
+    m_dottedPen = *wxGREY_PEN;
+#endif
  
  
-//  m_dottedPen = wxPen( "grey", 0, wxDOT );  too slow under XFree86
-    m_dottedPen = wxPen( wxT("grey"), 0, 0 );
+    SetInitialSize(size);
  
  
-    return TRUE;
+    return true;
  }
  
  wxGenericTreeCtrl::~wxGenericTreeCtrl()
  }
  
  wxGenericTreeCtrl::~wxGenericTreeCtrl()
@@ -768,39 +1036,46 @@ wxGenericTreeCtrl::~wxGenericTreeCtrl()
      delete m_hilightBrush;
      delete m_hilightUnfocusedBrush;
  
      delete m_hilightBrush;
      delete m_hilightUnfocusedBrush;
  
-    if (m_arrowRight) delete m_arrowRight;
-    if (m_arrowDown) delete m_arrowDown;
-
      DeleteAllItems();
  
      delete m_renameTimer;
      DeleteAllItems();
  
      delete m_renameTimer;
-    if (m_ownsImageListNormal) delete m_imageListNormal;
-    if (m_ownsImageListState) delete m_imageListState;
-    if (m_ownsImageListButtons) delete m_imageListButtons;
+    delete m_findTimer;
+
+    if (m_ownsImageListButtons)
+        delete m_imageListButtons;
  }
  
  // -----------------------------------------------------------------------------
  // accessors
  // -----------------------------------------------------------------------------
  
  }
  
  // -----------------------------------------------------------------------------
  // accessors
  // -----------------------------------------------------------------------------
  
-size_t wxGenericTreeCtrl::GetCount() const
+unsigned int wxGenericTreeCtrl::GetCount() const
  {
  {
-    return m_anchor == NULL ? 0u : m_anchor->GetChildrenCount();
+    if ( !m_anchor )
+    {
+        // the tree is empty
+        return 0;
+    }
+
+    unsigned int count = m_anchor->GetChildrenCount();
+    if ( !HasFlag(wxTR_HIDE_ROOT) )
+    {
+        // take the root itself into account
+        count++;
+    }
+
+    return count;
  }
  
  void wxGenericTreeCtrl::SetIndent(unsigned int indent)
  {
      m_indent = (unsigned short) indent;
  }
  
  void wxGenericTreeCtrl::SetIndent(unsigned int indent)
  {
      m_indent = (unsigned short) indent;
-    m_dirty = TRUE;
-}
-
-void wxGenericTreeCtrl::SetSpacing(unsigned int spacing)
-{
-    m_spacing = (unsigned short) spacing;
-    m_dirty = TRUE;
+    m_dirty = true;
  }
  
  }
  
-size_t wxGenericTreeCtrl::GetChildrenCount(const wxTreeItemId& item, bool recursively)
+size_t
+wxGenericTreeCtrl::GetChildrenCount(const wxTreeItemId& item,
+                                    bool recursively) const
  {
      wxCHECK_MSG( item.IsOk(), 0u, wxT("invalid tree item") );
  
  {
      wxCHECK_MSG( item.IsOk(), 0u, wxT("invalid tree item") );
  
@@ -809,11 +1084,20 @@ size_t wxGenericTreeCtrl::GetChildrenCount(const wxTreeItemId& item, bool recurs
  
  void wxGenericTreeCtrl::SetWindowStyle(const long styles)
  {
  
  void wxGenericTreeCtrl::SetWindowStyle(const long styles)
  {
-        // right now, just sets the styles.  Eventually, we may
-        // want to update the inherited styles, but right now
-        // none of the parents has updatable styles
+    // Do not try to expand the root node if it hasn't been created yet
+    if (m_anchor && !HasFlag(wxTR_HIDE_ROOT) && (styles & wxTR_HIDE_ROOT))
+    {
+        // if we will hide the root, make sure children are visible
+        m_anchor->SetHasPlus();
+        m_anchor->Expand();
+        CalculatePositions();
+    }
+
+    // right now, just sets the styles.  Eventually, we may
+    // want to update the inherited styles, but right now
+    // none of the parents has updatable styles
      m_windowStyle = styles;
      m_windowStyle = styles;
-    m_dirty = TRUE;
+    m_dirty = true;
  }
  
  // -----------------------------------------------------------------------------
  }
  
  // -----------------------------------------------------------------------------
@@ -822,7 +1106,7 @@ void wxGenericTreeCtrl::SetWindowStyle(const long styles)
  
  wxString wxGenericTreeCtrl::GetItemText(const wxTreeItemId& item) const
  {
  
  wxString wxGenericTreeCtrl::GetItemText(const wxTreeItemId& item) const
  {
-    wxCHECK_MSG( item.IsOk(), wxT(""), wxT("invalid tree item") );
+    wxCHECK_MSG( item.IsOk(), wxEmptyString, wxT("invalid tree item") );
  
      return ((wxGenericTreeItem*) item.m_pItem)->GetText();
  }
  
      return ((wxGenericTreeItem*) item.m_pItem)->GetText();
  }
@@ -842,14 +1126,47 @@ wxTreeItemData *wxGenericTreeCtrl::GetItemData(const wxTreeItemId& item) const
      return ((wxGenericTreeItem*) item.m_pItem)->GetData();
  }
  
      return ((wxGenericTreeItem*) item.m_pItem)->GetData();
  }
  
-void wxGenericTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text)
+int wxGenericTreeCtrl::DoGetItemState(const wxTreeItemId& item) const
+{
+    wxCHECK_MSG( item.IsOk(), wxTREE_ITEMSTATE_NONE, wxT("invalid tree item") );
+
+    wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
+    return pItem->GetState();
+}
+
+wxColour wxGenericTreeCtrl::GetItemTextColour(const wxTreeItemId& item) const
+{
+    wxCHECK_MSG( item.IsOk(), wxNullColour, wxT("invalid tree item") );
+
+    wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
+    return pItem->Attr().GetTextColour();
+}
+
+wxColour
+wxGenericTreeCtrl::GetItemBackgroundColour(const wxTreeItemId& item) const
+{
+    wxCHECK_MSG( item.IsOk(), wxNullColour, wxT("invalid tree item") );
+
+    wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
+    return pItem->Attr().GetBackgroundColour();
+}
+
+wxFont wxGenericTreeCtrl::GetItemFont(const wxTreeItemId& item) const
+{
+    wxCHECK_MSG( item.IsOk(), wxNullFont, wxT("invalid tree item") );
+
+    wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
+    return pItem->Attr().GetFont();
+}
+
+void
+wxGenericTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text)
  {
      wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
  
  {
      wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
  
-    wxClientDC dc(this);
      wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
      pItem->SetText(text);
      wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
      pItem->SetText(text);
-    CalculateSize(pItem, dc);
+    pItem->CalculateSize(this);
      RefreshLine(pItem);
  }
  
      RefreshLine(pItem);
  }
  
@@ -861,19 +1178,31 @@ void wxGenericTreeCtrl::SetItemImage(const wxTreeItemId& item,
  
      wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
      pItem->SetImage(image, which);
  
      wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
      pItem->SetImage(image, which);
-
-    wxClientDC dc(this);
-    CalculateSize(pItem, dc);
+    pItem->CalculateSize(this);
      RefreshLine(pItem);
  }
  
      RefreshLine(pItem);
  }
  
-void wxGenericTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data)
+void
+wxGenericTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data)
  {
      wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
  
  {
      wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
  
+    if (data)
+        data->SetId( item );
+
      ((wxGenericTreeItem*) item.m_pItem)->SetData(data);
  }
  
      ((wxGenericTreeItem*) item.m_pItem)->SetData(data);
  }
  
+void wxGenericTreeCtrl::DoSetItemState(const wxTreeItemId& item, int state)
+{
+    wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
+
+    wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
+    pItem->SetState(state);
+    pItem->CalculateSize(this);
+    RefreshLine(pItem);
+}
+
  void wxGenericTreeCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
  {
      wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
  void wxGenericTreeCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
  {
      wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
@@ -892,10 +1221,33 @@ void wxGenericTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
      if ( pItem->IsBold() != bold )
      {
          pItem->SetBold(bold);
      if ( pItem->IsBold() != bold )
      {
          pItem->SetBold(bold);
+
+        // recalculate the item size as bold and non bold fonts have different
+        // widths
+        pItem->CalculateSize(this);
          RefreshLine(pItem);
      }
  }
  
          RefreshLine(pItem);
      }
  }
  
+void wxGenericTreeCtrl::SetItemDropHighlight(const wxTreeItemId& item,
+                                             bool highlight)
+{
+    wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
+
+    wxColour fg, bg;
+
+    if (highlight)
+    {
+        bg = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
+        fg = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
+    }
+
+    wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
+    pItem->Attr().SetTextColour(fg);
+    pItem->Attr().SetBackgroundColour(bg);
+    RefreshLine(pItem);
+}
+
  void wxGenericTreeCtrl::SetItemTextColour(const wxTreeItemId& item,
                                     const wxColour& col)
  {
  void wxGenericTreeCtrl::SetItemTextColour(const wxTreeItemId& item,
                                     const wxColour& col)
  {
@@ -916,27 +1268,29 @@ void wxGenericTreeCtrl::SetItemBackgroundColour(const wxTreeItemId& item,
      RefreshLine(pItem);
  }
  
      RefreshLine(pItem);
  }
  
-void wxGenericTreeCtrl::SetItemFont(const wxTreeItemId& item, const wxFont& font)
+void
+wxGenericTreeCtrl::SetItemFont(const wxTreeItemId& item, const wxFont& font)
  {
      wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
  
      wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
      pItem->Attr().SetFont(font);
  {
      wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
  
      wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
      pItem->Attr().SetFont(font);
+    pItem->ResetTextSize();
+    pItem->CalculateSize(this);
      RefreshLine(pItem);
  }
  
  bool wxGenericTreeCtrl::SetFont( const wxFont &font )
  {
      RefreshLine(pItem);
  }
  
  bool wxGenericTreeCtrl::SetFont( const wxFont &font )
  {
-    wxScrolledWindow::SetFont(font);
+    wxTreeCtrlBase::SetFont(font);
+
+    m_normalFont = font;
+    m_boldFont = m_normalFont.Bold();
  
  
-    m_normalFont = font ;
-    m_boldFont = wxFont( m_normalFont.GetPointSize(),
-                            m_normalFont.GetFamily(),
-                            m_normalFont.GetStyle(),
-                            wxBOLD,
-                            m_normalFont.GetUnderlined());
+    if (m_anchor)
+        m_anchor->RecursiveResetTextSize();
  
  
-    return TRUE;
+    return true;
  }
  
  
  }
  
  
@@ -946,7 +1300,7 @@ bool wxGenericTreeCtrl::SetFont( const wxFont &font )
  
  bool wxGenericTreeCtrl::IsVisible(const wxTreeItemId& item) const
  {
  
  bool wxGenericTreeCtrl::IsVisible(const wxTreeItemId& item) const
  {
-    wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
+    wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
  
      // An item is only visible if it's not a descendant of a collapsed item
      wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
  
      // An item is only visible if it's not a descendant of a collapsed item
      wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
@@ -954,7 +1308,7 @@ bool wxGenericTreeCtrl::IsVisible(const wxTreeItemId& item) const
      while (parent)
      {
          if (!parent->IsExpanded())
      while (parent)
      {
          if (!parent->IsExpanded())
-            return FALSE;
+            return false;
          parent = parent->GetParent();
      }
  
          parent = parent->GetParent();
      }
  
@@ -965,20 +1319,20 @@ bool wxGenericTreeCtrl::IsVisible(const wxTreeItemId& item) const
  
      wxRect rect;
      if (!GetBoundingRect(item, rect))
  
      wxRect rect;
      if (!GetBoundingRect(item, rect))
-        return FALSE;
+        return false;
      if (rect.GetWidth() == 0 || rect.GetHeight() == 0)
      if (rect.GetWidth() == 0 || rect.GetHeight() == 0)
-        return FALSE;
+        return false;
      if (rect.GetBottom() < 0 || rect.GetTop() > clientSize.y)
      if (rect.GetBottom() < 0 || rect.GetTop() > clientSize.y)
-        return FALSE;
+        return false;
      if (rect.GetRight() < 0 || rect.GetLeft() > clientSize.x)
      if (rect.GetRight() < 0 || rect.GetLeft() > clientSize.x)
-        return FALSE;
+        return false;
  
  
-    return TRUE;
+    return true;
  }
  
  bool wxGenericTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const
  {
  }
  
  bool wxGenericTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const
  {
-    wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
+    wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
  
      // consider that the item does have children if it has the "+" button: it
      // might not have them (if it had never been expanded yet) but then it
  
      // consider that the item does have children if it has the "+" button: it
      // might not have them (if it had never been expanded yet) but then it
@@ -990,21 +1344,21 @@ bool wxGenericTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const
  
  bool wxGenericTreeCtrl::IsExpanded(const wxTreeItemId& item) const
  {
  
  bool wxGenericTreeCtrl::IsExpanded(const wxTreeItemId& item) const
  {
-    wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
+    wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
  
      return ((wxGenericTreeItem*) item.m_pItem)->IsExpanded();
  }
  
  bool wxGenericTreeCtrl::IsSelected(const wxTreeItemId& item) const
  {
  
      return ((wxGenericTreeItem*) item.m_pItem)->IsExpanded();
  }
  
  bool wxGenericTreeCtrl::IsSelected(const wxTreeItemId& item) const
  {
-    wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
+    wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
  
      return ((wxGenericTreeItem*) item.m_pItem)->IsSelected();
  }
  
  bool wxGenericTreeCtrl::IsBold(const wxTreeItemId& item) const
  {
  
      return ((wxGenericTreeItem*) item.m_pItem)->IsSelected();
  }
  
  bool wxGenericTreeCtrl::IsBold(const wxTreeItemId& item) const
  {
-    wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
+    wxCHECK_MSG( item.IsOk(), false, wxT("invalid tree item") );
  
      return ((wxGenericTreeItem*) item.m_pItem)->IsBold();
  }
  
      return ((wxGenericTreeItem*) item.m_pItem)->IsBold();
  }
@@ -1013,14 +1367,15 @@ bool wxGenericTreeCtrl::IsBold(const wxTreeItemId& item) const
  // navigation
  // -----------------------------------------------------------------------------
  
  // navigation
  // -----------------------------------------------------------------------------
  
-wxTreeItemId wxGenericTreeCtrl::GetParent(const wxTreeItemId& item) const
+wxTreeItemId wxGenericTreeCtrl::GetItemParent(const wxTreeItemId& item) const
  {
      wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
  
      return ((wxGenericTreeItem*) item.m_pItem)->GetParent();
  }
  
  {
      wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
  
      return ((wxGenericTreeItem*) item.m_pItem)->GetParent();
  }
  
-wxTreeItemId wxGenericTreeCtrl::GetFirstChild(const wxTreeItemId& item, long& cookie) const
+wxTreeItemId wxGenericTreeCtrl::GetFirstChild(const wxTreeItemId& item,
+                                              wxTreeItemIdValue& cookie) const
  {
      wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
  
  {
      wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
  
@@ -1028,14 +1383,20 @@ wxTreeItemId wxGenericTreeCtrl::GetFirstChild(const wxTreeItemId& item, long& co
      return GetNextChild(item, cookie);
  }
  
      return GetNextChild(item, cookie);
  }
  
-wxTreeItemId wxGenericTreeCtrl::GetNextChild(const wxTreeItemId& item, long& cookie) const
+wxTreeItemId wxGenericTreeCtrl::GetNextChild(const wxTreeItemId& item,
+                                             wxTreeItemIdValue& cookie) const
  {
      wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
  
  {
      wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
  
-    wxArrayGenericTreeItems& children = ((wxGenericTreeItem*) item.m_pItem)->GetChildren();
-    if ( (size_t)cookie < children.Count() )
+    wxArrayGenericTreeItems&
+        children = ((wxGenericTreeItem*) item.m_pItem)->GetChildren();
+
+    // it's ok to cast cookie to size_t, we never have indices big enough to
+    // overflow "void *"
+    size_t *pIndex = (size_t *)&cookie;
+    if ( *pIndex < children.GetCount() )
      {
      {
-        return children.Item((size_t)cookie++);
+        return children.Item((*pIndex)++);
      }
      else
      {
      }
      else
      {
@@ -1048,8 +1409,9 @@ wxTreeItemId wxGenericTreeCtrl::GetLastChild(const wxTreeItemId& item) const
  {
      wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
  
  {
      wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
  
-    wxArrayGenericTreeItems& children = ((wxGenericTreeItem*) item.m_pItem)->GetChildren();
-    return (children.IsEmpty() ? wxTreeItemId() : wxTreeItemId(children.Last()));
+    wxArrayGenericTreeItems&
+        children = ((wxGenericTreeItem*) item.m_pItem)->GetChildren();
+    return children.IsEmpty() ? wxTreeItemId() : wxTreeItemId(children.Last());
  }
  
  wxTreeItemId wxGenericTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
  }
  
  wxTreeItemId wxGenericTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
@@ -1069,7 +1431,8 @@ wxTreeItemId wxGenericTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
      wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
  
      size_t n = (size_t)(index + 1);
      wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
  
      size_t n = (size_t)(index + 1);
-    return n == siblings.Count() ? wxTreeItemId() : wxTreeItemId(siblings[n]);
+    return n == siblings.GetCount() ? wxTreeItemId()
+                                    : wxTreeItemId(siblings[n]);
  }
  
  wxTreeItemId wxGenericTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const
  }
  
  wxTreeItemId wxGenericTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const
@@ -1113,7 +1476,7 @@ wxTreeItemId wxGenericTreeCtrl::GetNext(const wxTreeItemId& item) const
           do
           {
                toFind = GetNextSibling(p);
           do
           {
                toFind = GetNextSibling(p);
-              p = GetParent(p);
+              p = GetItemParent(p);
           } while (p.IsOk() && !toFind.IsOk());
           return toFind;
      }
           } while (p.IsOk() && !toFind.IsOk());
           return toFind;
      }
@@ -1121,16 +1484,16 @@ wxTreeItemId wxGenericTreeCtrl::GetNext(const wxTreeItemId& item) const
  
  wxTreeItemId wxGenericTreeCtrl::GetFirstVisibleItem() const
  {
  
  wxTreeItemId wxGenericTreeCtrl::GetFirstVisibleItem() const
  {
-    wxTreeItemId id = GetRootItem();
-    if (!id.IsOk())
-        return id;
+    wxTreeItemId itemid = GetRootItem();
+    if (!itemid.IsOk())
+        return itemid;
  
      do
      {
  
      do
      {
-        if (IsVisible(id))
-              return id;
-        id = GetNext(id);
-    } while (id.IsOk());
+        if (IsVisible(itemid))
+              return itemid;
+        itemid = GetNext(itemid);
+    } while (itemid.IsOk());
  
      return wxTreeItemId();
  }
  
      return wxTreeItemId();
  }
@@ -1138,6 +1501,7 @@ wxTreeItemId wxGenericTreeCtrl::GetFirstVisibleItem() const
  wxTreeItemId wxGenericTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
  {
      wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
  wxTreeItemId wxGenericTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
  {
      wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
+    wxASSERT_MSG( IsVisible(item), wxT("this item itself should be visible") );
  
      wxTreeItemId id = item;
      if (id.IsOk())
  
      wxTreeItemId id = item;
      if (id.IsOk())
@@ -1154,10 +1518,92 @@ wxTreeItemId wxGenericTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
  wxTreeItemId wxGenericTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
  {
      wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
  wxTreeItemId wxGenericTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
  {
      wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
+    wxASSERT_MSG( IsVisible(item), wxT("this item itself should be visible") );
  
  
-    wxFAIL_MSG(wxT("not implemented"));
+    // find out the starting point
+    wxTreeItemId prevItem = GetPrevSibling(item);
+    if ( !prevItem.IsOk() )
+    {
+        prevItem = GetItemParent(item);
+    }
  
  
-    return wxTreeItemId();
+    // find the first visible item after it
+    while ( prevItem.IsOk() && !IsVisible(prevItem) )
+    {
+        prevItem = GetNext(prevItem);
+        if ( !prevItem.IsOk() || prevItem == item )
+        {
+            // there are no visible items before item
+            return wxTreeItemId();
+        }
+    }
+
+    // from there we must be able to navigate until this item
+    while ( prevItem.IsOk() )
+    {
+        const wxTreeItemId nextItem = GetNextVisible(prevItem);
+        if ( !nextItem.IsOk() || nextItem == item )
+            break;
+
+        prevItem = nextItem;
+    }
+
+    return prevItem;
+}
+
+// called by wxTextTreeCtrl when it marks itself for deletion
+void wxGenericTreeCtrl::ResetTextControl()
+{
+    m_textCtrl = NULL;
+}
+
+// find the first item starting with the given prefix after the given item
+wxTreeItemId wxGenericTreeCtrl::FindItem(const wxTreeItemId& idParent,
+                                         const wxString& prefixOrig) const
+{
+    // match is case insensitive as this is more convenient to the user: having
+    // to press Shift-letter to go to the item starting with a capital letter
+    // would be too bothersome
+    wxString prefix = prefixOrig.Lower();
+
+    // determine the starting point: we shouldn't take the current item (this
+    // allows to switch between two items starting with the same letter just by
+    // pressing it) but we shouldn't jump to the next one if the user is
+    // continuing to type as otherwise he might easily skip the item he wanted
+    wxTreeItemId itemid = idParent;
+    if ( prefix.length() == 1 )
+    {
+        itemid = GetNext(itemid);
+    }
+
+    // look for the item starting with the given prefix after it
+    while ( itemid.IsOk() && !GetItemText(itemid).Lower().StartsWith(prefix) )
+    {
+        itemid = GetNext(itemid);
+    }
+
+    // if we haven't found anything...
+    if ( !itemid.IsOk() )
+    {
+        // ... wrap to the beginning
+        itemid = GetRootItem();
+        if ( HasFlag(wxTR_HIDE_ROOT) )
+        {
+            // can't select virtual root
+            itemid = GetNext(itemid);
+        }
+
+        // and try all the items (stop when we get to the one we started from)
+        while ( itemid.IsOk() && itemid != idParent &&
+                    !GetItemText(itemid).Lower().StartsWith(prefix) )
+        {
+            itemid = GetNext(itemid);
+        }
+        // If we haven't found the item, id.IsOk() will be false, as per
+        // documentation
+    }
+
+    return itemid;
  }
  
  // -----------------------------------------------------------------------------
  }
  
  // -----------------------------------------------------------------------------
@@ -1165,10 +1611,11 @@ wxTreeItemId wxGenericTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
  // -----------------------------------------------------------------------------
  
  wxTreeItemId wxGenericTreeCtrl::DoInsertItem(const wxTreeItemId& parentId,
  // -----------------------------------------------------------------------------
  
  wxTreeItemId wxGenericTreeCtrl::DoInsertItem(const wxTreeItemId& parentId,
-                                      size_t previous,
-                                      const wxString& text,
-                                      int image, int selImage,
-                                      wxTreeItemData *data)
+                                             size_t previous,
+                                             const wxString& text,
+                                             int image,
+                                             int selImage,
+                                             wxTreeItemData *data)
  {
      wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem;
      if ( !parent )
  {
      wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem;
      if ( !parent )
@@ -1177,34 +1624,37 @@ wxTreeItemId wxGenericTreeCtrl::DoInsertItem(const wxTreeItemId& parentId,
          return AddRoot(text, image, selImage, data);
      }
  
          return AddRoot(text, image, selImage, data);
      }
  
-    m_dirty = TRUE;     // do this first so stuff below doesn't cause flicker
+    m_dirty = true;     // do this first so stuff below doesn't cause flicker
  
      wxGenericTreeItem *item =
          new wxGenericTreeItem( parent, text, image, selImage, data );
  
      if ( data != NULL )
      {
  
      wxGenericTreeItem *item =
          new wxGenericTreeItem( parent, text, image, selImage, data );
  
      if ( data != NULL )
      {
-        data->m_pItem = (long) item;
+        data->m_pItem = item;
      }
  
      }
  
-    parent->Insert( item, previous );
+    parent->Insert( item, previous == (size_t)-1 ? parent->GetChildren().size()
+                                                 : previous );
  
  
+    InvalidateBestSize();
      return item;
  }
  
  wxTreeItemId wxGenericTreeCtrl::AddRoot(const wxString& text,
      return item;
  }
  
  wxTreeItemId wxGenericTreeCtrl::AddRoot(const wxString& text,
-                                 int image, int selImage,
-                                 wxTreeItemData *data)
+                                        int image,
+                                        int selImage,
+                                        wxTreeItemData *data)
  {
  {
-    wxCHECK_MSG( !m_anchor, wxTreeItemId(), wxT("tree can have only one root") );
+    wxCHECK_MSG( !m_anchor, wxTreeItemId(), "tree can have only one root" );
  
  
-    m_dirty = TRUE;     // do this first so stuff below doesn't cause flicker
+    m_dirty = true;     // do this first so stuff below doesn't cause flicker
  
  
-    m_anchor = new wxGenericTreeItem((wxGenericTreeItem *)NULL, text,
+    m_anchor = new wxGenericTreeItem(NULL, text,
                                     image, selImage, data);
      if ( data != NULL )
      {
                                     image, selImage, data);
      if ( data != NULL )
      {
-        data->m_pItem = (long) m_anchor;
+        data->m_pItem = m_anchor;
      }
  
      if (HasFlag(wxTR_HIDE_ROOT))
      }
  
      if (HasFlag(wxTR_HIDE_ROOT))
@@ -1212,31 +1662,25 @@ wxTreeItemId wxGenericTreeCtrl::AddRoot(const wxString& text,
          // if root is hidden, make sure we can navigate
          // into children
          m_anchor->SetHasPlus();
          // if root is hidden, make sure we can navigate
          // into children
          m_anchor->SetHasPlus();
-        Expand(m_anchor);
+        m_anchor->Expand();
+        CalculatePositions();
      }
  
      if (!HasFlag(wxTR_MULTIPLE))
      {
          m_current = m_key_current = m_anchor;
      }
  
      if (!HasFlag(wxTR_MULTIPLE))
      {
          m_current = m_key_current = m_anchor;
-        m_current->SetHilight( TRUE );
+        m_current->SetHilight( true );
      }
  
      }
  
+    InvalidateBestSize();
      return m_anchor;
  }
  
      return m_anchor;
  }
  
-wxTreeItemId wxGenericTreeCtrl::PrependItem(const wxTreeItemId& parent,
-                                     const wxString& text,
-                                     int image, int selImage,
-                                     wxTreeItemData *data)
-{
-    return DoInsertItem(parent, 0u, text, image, selImage, data);
-}
-
-wxTreeItemId wxGenericTreeCtrl::InsertItem(const wxTreeItemId& parentId,
-                                    const wxTreeItemId& idPrevious,
-                                    const wxString& text,
-                                    int image, int selImage,
-                                    wxTreeItemData *data)
+wxTreeItemId wxGenericTreeCtrl::DoInsertAfter(const wxTreeItemId& parentId,
+                                              const wxTreeItemId& idPrevious,
+                                              const wxString& text,
+                                              int image, int selImage,
+                                              wxTreeItemData *data)
  {
      wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem;
      if ( !parent )
  {
      wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem;
      if ( !parent )
@@ -1245,109 +1689,144 @@ wxTreeItemId wxGenericTreeCtrl::InsertItem(const wxTreeItemId& parentId,
          return AddRoot(text, image, selImage, data);
      }
  
          return AddRoot(text, image, selImage, data);
      }
  
-    int index = parent->GetChildren().Index((wxGenericTreeItem*) idPrevious.m_pItem);
-    wxASSERT_MSG( index != wxNOT_FOUND,
-                  wxT("previous item in wxGenericTreeCtrl::InsertItem() is not a sibling") );
+    int index = -1;
+    if (idPrevious.IsOk())
+    {
+        index = parent->GetChildren().Index(
+                    (wxGenericTreeItem*) idPrevious.m_pItem);
+        wxASSERT_MSG( index != wxNOT_FOUND,
+                      "previous item in wxGenericTreeCtrl::InsertItem() "
+                      "is not a sibling" );
+    }
  
      return DoInsertItem(parentId, (size_t)++index, text, image, selImage, data);
  }
  
  
      return DoInsertItem(parentId, (size_t)++index, text, image, selImage, data);
  }
  
-wxTreeItemId wxGenericTreeCtrl::InsertItem(const wxTreeItemId& parentId,
-                                    size_t before,
-                                    const wxString& text,
-                                    int image, int selImage,
-                                    wxTreeItemData *data)
-{
-    wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem;
-    if ( !parent )
-    {
-        // should we give a warning here?
-        return AddRoot(text, image, selImage, data);
-    }
  
  
-    return DoInsertItem(parentId, before, text, image, selImage, data);
+void wxGenericTreeCtrl::SendDeleteEvent(wxGenericTreeItem *item)
+{
+    wxTreeEvent event(wxEVT_COMMAND_TREE_DELETE_ITEM, this, item);
+    GetEventHandler()->ProcessEvent( event );
  }
  
  }
  
-wxTreeItemId wxGenericTreeCtrl::AppendItem(const wxTreeItemId& parentId,
-                                    const wxString& text,
-                                    int image, int selImage,
-                                    wxTreeItemData *data)
+// Don't leave edit or selection on a child which is about to disappear
+void wxGenericTreeCtrl::ChildrenClosing(wxGenericTreeItem* item)
  {
  {
-    wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem;
-    if ( !parent )
+    if ( m_textCtrl && item != m_textCtrl->item() &&
+            IsDescendantOf(item, m_textCtrl->item()) )
      {
      {
-        // should we give a warning here?
-        return AddRoot(text, image, selImage, data);
+        m_textCtrl->EndEdit( true );
      }
  
      }
  
-    return DoInsertItem( parent, parent->GetChildren().Count(), text,
-                         image, selImage, data);
-}
+    if ( item != m_key_current && IsDescendantOf(item, m_key_current) )
+    {
+        m_key_current = NULL;
+    }
  
  
-void wxGenericTreeCtrl::SendDeleteEvent(wxGenericTreeItem *item)
-{
-    wxTreeEvent event( wxEVT_COMMAND_TREE_DELETE_ITEM, GetId() );
-    event.m_item = (long) item;
-    event.SetEventObject( this );
-    ProcessEvent( event );
+    if ( IsDescendantOf(item, m_select_me) )
+    {
+        m_select_me = item;
+    }
+
+    if ( item != m_current && IsDescendantOf(item, m_current) )
+    {
+        m_current->SetHilight( false );
+        m_current = NULL;
+        m_select_me = item;
+    }
  }
  
  void wxGenericTreeCtrl::DeleteChildren(const wxTreeItemId& itemId)
  {
  }
  
  void wxGenericTreeCtrl::DeleteChildren(const wxTreeItemId& itemId)
  {
-    m_dirty = TRUE;     // do this first so stuff below doesn't cause flicker
+    m_dirty = true;     // do this first so stuff below doesn't cause flicker
  
      wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
  
      wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
+    ChildrenClosing(item);
      item->DeleteChildren(this);
      item->DeleteChildren(this);
+    InvalidateBestSize();
  }
  
  void wxGenericTreeCtrl::Delete(const wxTreeItemId& itemId)
  {
  }
  
  void wxGenericTreeCtrl::Delete(const wxTreeItemId& itemId)
  {
-    m_dirty = TRUE;     // do this first so stuff below doesn't cause flicker
+    m_dirty = true;     // do this first so stuff below doesn't cause flicker
  
      wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
  
  
      wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
  
-    // don't stay with invalid m_key_current or we will crash in
-    // the next call to OnChar()
-    bool changeKeyCurrent = FALSE;
-    wxGenericTreeItem *itemKey = m_key_current;
-    while ( itemKey )
+    if (m_textCtrl != NULL && IsDescendantOf(item, m_textCtrl->item()))
      {
      {
-        if ( itemKey == item )
-        {
-            // m_key_current is a descendant of the item being deleted
-            changeKeyCurrent = TRUE;
-            break;
-        }
-        itemKey = itemKey->GetParent();
+        // can't delete the item being edited, cancel editing it first
+        m_textCtrl->EndEdit( true );
      }
  
      wxGenericTreeItem *parent = item->GetParent();
      }
  
      wxGenericTreeItem *parent = item->GetParent();
+
+    // if the selected item will be deleted, select the parent ...
+    wxGenericTreeItem *to_be_selected = parent;
+    if (parent)
+    {
+        // .. unless there is a next sibling like wxMSW does it
+        int pos = parent->GetChildren().Index( item );
+        if ((int)(parent->GetChildren().GetCount()) > pos+1)
+            to_be_selected = parent->GetChildren().Item( pos+1 );
+    }
+
+    // don't keep stale pointers around!
+    if ( IsDescendantOf(item, m_key_current) )
+    {
+        // Don't silently change the selection:
+        // do it properly in idle time, so event
+        // handlers get called.
+
+        // m_key_current = parent;
+        m_key_current = NULL;
+    }
+
+    // m_select_me records whether we need to select
+    // a different item, in idle time.
+    if ( m_select_me && IsDescendantOf(item, m_select_me) )
+    {
+        m_select_me = to_be_selected;
+    }
+
+    if ( IsDescendantOf(item, m_current) )
+    {
+        // Don't silently change the selection:
+        // do it properly in idle time, so event
+        // handlers get called.
+
+        // m_current = parent;
+        m_current = NULL;
+        m_select_me = to_be_selected;
+    }
+
+    // remove the item from the tree
      if ( parent )
      {
          parent->GetChildren().Remove( item );  // remove by value
      }
      if ( parent )
      {
          parent->GetChildren().Remove( item );  // remove by value
      }
-
-    if ( changeKeyCurrent )
+    else // deleting the root
      {
      {
-        // may be NULL or not
-        m_key_current = parent;
+        // nothing will be left in the tree
+        m_anchor = NULL;
      }
  
      }
  
+    // and delete all of its children and the item itself now
      item->DeleteChildren(this);
      SendDeleteEvent(item);
      item->DeleteChildren(this);
      SendDeleteEvent(item);
+
+    if (item == m_select_me)
+        m_select_me = NULL;
+
      delete item;
      delete item;
+
+    InvalidateBestSize();
  }
  
  void wxGenericTreeCtrl::DeleteAllItems()
  {
      if ( m_anchor )
      {
  }
  
  void wxGenericTreeCtrl::DeleteAllItems()
  {
      if ( m_anchor )
      {
-        m_dirty = TRUE;
-
-        m_anchor->DeleteChildren(this);
-        delete m_anchor;
-
-        m_anchor = NULL;
+        Delete(m_anchor);
      }
  }
  
      }
  }
  
@@ -1355,7 +1834,9 @@ void wxGenericTreeCtrl::Expand(const wxTreeItemId& itemId)
  {
      wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
  
  {
      wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
  
-    wxCHECK_RET( item, _T("invalid item in wxGenericTreeCtrl::Expand") );
+    wxCHECK_RET( item, wxT("invalid item in wxGenericTreeCtrl::Expand") );
+    wxCHECK_RET( !HasFlag(wxTR_HIDE_ROOT) || itemId != GetRootItem(),
+                 wxT("can't expand hidden root") );
  
      if ( !item->HasPlus() )
          return;
  
      if ( !item->HasPlus() )
          return;
@@ -1363,62 +1844,53 @@ void wxGenericTreeCtrl::Expand(const wxTreeItemId& itemId)
      if ( item->IsExpanded() )
          return;
  
      if ( item->IsExpanded() )
          return;
  
-    wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_EXPANDING, GetId() );
-    event.m_item = (long) item;
-    event.SetEventObject( this );
+    wxTreeEvent event(wxEVT_COMMAND_TREE_ITEM_EXPANDING, this, item);
  
  
-    if ( ProcessEvent( event ) && !event.IsAllowed() )
+    if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() )
      {
          // cancelled by program
          return;
      }
  
      item->Expand();
      {
          // cancelled by program
          return;
      }
  
      item->Expand();
-    CalculatePositions();
-
-    RefreshSubtree(item);
-
-    event.SetEventType(wxEVT_COMMAND_TREE_ITEM_EXPANDED);
-    ProcessEvent( event );
-}
-
-void wxGenericTreeCtrl::ExpandAll(const wxTreeItemId& item)
-{
-    Expand(item);
-    if ( IsExpanded(item) )
+    if ( !IsFrozen() )
      {
      {
-        long cookie;
-        wxTreeItemId child = GetFirstChild(item, cookie);
-        while ( child.IsOk() )
-        {
-            ExpandAll(child);
+        CalculatePositions();
  
  
-            child = GetNextChild(item, cookie);
-        }
+        RefreshSubtree(item);
+    }
+    else // frozen
+    {
+        m_dirty = true;
      }
      }
+
+    event.SetEventType(wxEVT_COMMAND_TREE_ITEM_EXPANDED);
+    GetEventHandler()->ProcessEvent( event );
  }
  
  void wxGenericTreeCtrl::Collapse(const wxTreeItemId& itemId)
  {
  }
  
  void wxGenericTreeCtrl::Collapse(const wxTreeItemId& itemId)
  {
+    wxCHECK_RET( !HasFlag(wxTR_HIDE_ROOT) || itemId != GetRootItem(),
+                 wxT("can't collapse hidden root") );
+
      wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
  
      if ( !item->IsExpanded() )
          return;
  
      wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
  
      if ( !item->IsExpanded() )
          return;
  
-    wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_COLLAPSING, GetId() );
-    event.m_item = (long) item;
-    event.SetEventObject( this );
-    if ( ProcessEvent( event ) && !event.IsAllowed() )
+    wxTreeEvent event(wxEVT_COMMAND_TREE_ITEM_COLLAPSING, this, item);
+    if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() )
      {
          // cancelled by program
          return;
      }
  
      {
          // cancelled by program
          return;
      }
  
+    ChildrenClosing(item);
      item->Collapse();
  
  #if 0  // TODO why should items be collapsed recursively?
      wxArrayGenericTreeItems& children = item->GetChildren();
      item->Collapse();
  
  #if 0  // TODO why should items be collapsed recursively?
      wxArrayGenericTreeItems& children = item->GetChildren();
-    size_t count = children.Count();
+    size_t count = children.GetCount();
      for ( size_t n = 0; n < count; n++ )
      {
          Collapse(children[n]);
      for ( size_t n = 0; n < count; n++ )
      {
          Collapse(children[n]);
@@ -1430,7 +1902,7 @@ void wxGenericTreeCtrl::Collapse(const wxTreeItemId& itemId)
      RefreshSubtree(item);
  
      event.SetEventType(wxEVT_COMMAND_TREE_ITEM_COLLAPSED);
      RefreshSubtree(item);
  
      event.SetEventType(wxEVT_COMMAND_TREE_ITEM_COLLAPSED);
-    ProcessEvent( event );
+    GetEventHandler()->ProcessEvent( event );
  }
  
  void wxGenericTreeCtrl::CollapseAndReset(const wxTreeItemId& item)
  }
  
  void wxGenericTreeCtrl::CollapseAndReset(const wxTreeItemId& item)
@@ -1453,23 +1925,40 @@ void wxGenericTreeCtrl::Unselect()
  {
      if (m_current)
      {
  {
      if (m_current)
      {
-        m_current->SetHilight( FALSE );
+        m_current->SetHilight( false );
          RefreshLine( m_current );
          RefreshLine( m_current );
+
+        m_current = NULL;
+        m_select_me = NULL;
      }
  }
  
      }
  }
  
+void wxGenericTreeCtrl::ClearFocusedItem()
+{
+    wxTreeItemId item = GetFocusedItem();
+    if ( item.IsOk() )
+        SelectItem(item, false);
+}
+
+void wxGenericTreeCtrl::SetFocusedItem(const wxTreeItemId& item)
+{
+    wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
+
+    SelectItem(item, true);
+}
+
  void wxGenericTreeCtrl::UnselectAllChildren(wxGenericTreeItem *item)
  {
      if (item->IsSelected())
      {
  void wxGenericTreeCtrl::UnselectAllChildren(wxGenericTreeItem *item)
  {
      if (item->IsSelected())
      {
-        item->SetHilight(FALSE);
+        item->SetHilight(false);
          RefreshLine(item);
      }
  
      if (item->HasChildren())
      {
          wxArrayGenericTreeItems& children = item->GetChildren();
          RefreshLine(item);
      }
  
      if (item->HasChildren())
      {
          wxArrayGenericTreeItems& children = item->GetChildren();
-        size_t count = children.Count();
+        size_t count = children.GetCount();
          for ( size_t n = 0; n < count; ++n )
          {
              UnselectAllChildren(children[n]);
          for ( size_t n = 0; n < count; ++n )
          {
              UnselectAllChildren(children[n]);
@@ -1488,13 +1977,52 @@ void wxGenericTreeCtrl::UnselectAll()
      }
  }
  
      }
  }
  
+void wxGenericTreeCtrl::SelectChildren(const wxTreeItemId& parent)
+{
+    wxCHECK_RET( HasFlag(wxTR_MULTIPLE),
+                 "this only works with multiple selection controls" );
+
+    UnselectAll();
+
+    if ( !HasChildren(parent) )
+        return;
+
+
+    wxArrayGenericTreeItems&
+        children = ((wxGenericTreeItem*) parent.m_pItem)->GetChildren();
+    size_t count = children.GetCount();
+
+    wxGenericTreeItem *
+        item = (wxGenericTreeItem*) ((wxTreeItemId)children[0]).m_pItem;
+    wxTreeEvent event(wxEVT_COMMAND_TREE_SEL_CHANGING, this, item);
+    event.m_itemOld = m_current;
+
+    if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() )
+        return;
+
+    for ( size_t n = 0; n < count; ++n )
+    {
+        m_current = m_key_current = children[n];
+        m_current->SetHilight(true);
+        RefreshSelected();
+    }
+
+
+    event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
+    GetEventHandler()->ProcessEvent( event );
+}
+
+
  // Recursive function !
  // To stop we must have crt_item<last_item
  // Algorithm :
  // Tag all next children, when no more children,
  // Move to parent (not to tag)
  // Keep going... if we found last_item, we stop.
  // Recursive function !
  // To stop we must have crt_item<last_item
  // Algorithm :
  // Tag all next children, when no more children,
  // Move to parent (not to tag)
  // Keep going... if we found last_item, we stop.
-bool wxGenericTreeCtrl::TagNextChildren(wxGenericTreeItem *crt_item, wxGenericTreeItem *last_item, bool select)
+bool
+wxGenericTreeCtrl::TagNextChildren(wxGenericTreeItem *crt_item,
+                                   wxGenericTreeItem *last_item,
+                                   bool select)
  {
      wxGenericTreeItem *parent = crt_item->GetParent();
  
  {
      wxGenericTreeItem *parent = crt_item->GetParent();
  
@@ -1505,53 +2033,52 @@ bool wxGenericTreeCtrl::TagNextChildren(wxGenericTreeItem *crt_item, wxGenericTr
      int index = children.Index(crt_item);
      wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
  
      int index = children.Index(crt_item);
      wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
  
-    size_t count = children.Count();
+    size_t count = children.GetCount();
      for (size_t n=(size_t)(index+1); n<count; ++n)
      {
      for (size_t n=(size_t)(index+1); n<count; ++n)
      {
-        if (TagAllChildrenUntilLast(children[n], last_item, select)) return TRUE;
+        if ( TagAllChildrenUntilLast(children[n], last_item, select) )
+            return true;
      }
  
      return TagNextChildren(parent, last_item, select);
  }
  
      }
  
      return TagNextChildren(parent, last_item, select);
  }
  
-bool wxGenericTreeCtrl::TagAllChildrenUntilLast(wxGenericTreeItem *crt_item, wxGenericTreeItem *last_item, bool select)
+bool
+wxGenericTreeCtrl::TagAllChildrenUntilLast(wxGenericTreeItem *crt_item,
+                                           wxGenericTreeItem *last_item,
+                                           bool select)
  {
      crt_item->SetHilight(select);
      RefreshLine(crt_item);
  
      if (crt_item==last_item)
  {
      crt_item->SetHilight(select);
      RefreshLine(crt_item);
  
      if (crt_item==last_item)
-        return TRUE;
+        return true;
  
  
-    if (crt_item->HasChildren())
+    // We should leave the not shown children of collapsed items alone.
+    if (crt_item->HasChildren() && crt_item->IsExpanded())
      {
          wxArrayGenericTreeItems& children = crt_item->GetChildren();
      {
          wxArrayGenericTreeItems& children = crt_item->GetChildren();
-        size_t count = children.Count();
+        size_t count = children.GetCount();
          for ( size_t n = 0; n < count; ++n )
          {
              if (TagAllChildrenUntilLast(children[n], last_item, select))
          for ( size_t n = 0; n < count; ++n )
          {
              if (TagAllChildrenUntilLast(children[n], last_item, select))
-                return TRUE;
+                return true;
          }
      }
  
          }
      }
  
-  return FALSE;
+  return false;
  }
  
  }
  
-void wxGenericTreeCtrl::SelectItemRange(wxGenericTreeItem *item1, wxGenericTreeItem *item2)
+void
+wxGenericTreeCtrl::SelectItemRange(wxGenericTreeItem *item1,
+                                   wxGenericTreeItem *item2)
  {
  {
-    // item2 is not necessary after item1
-    wxGenericTreeItem *first=NULL, *last=NULL;
+    m_select_me = NULL;
  
  
+    // item2 is not necessary after item1
      // choice first' and 'last' between item1 and item2
      // choice first' and 'last' between item1 and item2
-    if (item1->GetY()<item2->GetY())
-    {
-        first=item1;
-        last=item2;
-    }
-    else
-    {
-        first=item2;
-        last=item1;
-    }
+    wxGenericTreeItem *first= (item1->GetY()<item2->GetY()) ? item1 : item2;
+    wxGenericTreeItem *last = (item1->GetY()<item2->GetY()) ? item2 : item1;
  
      bool select = m_current->IsSelected();
  
  
      bool select = m_current->IsSelected();
  
@@ -1561,12 +2088,14 @@ void wxGenericTreeCtrl::SelectItemRange(wxGenericTreeItem *item1, wxGenericTreeI
      TagNextChildren(first,last,select);
  }
  
      TagNextChildren(first,last,select);
  }
  
-void wxGenericTreeCtrl::SelectItem(const wxTreeItemId& itemId,
-                            bool unselect_others,
-                            bool extended_select)
+void wxGenericTreeCtrl::DoSelectItem(const wxTreeItemId& itemId,
+                                     bool unselect_others,
+                                     bool extended_select)
  {
      wxCHECK_RET( itemId.IsOk(), wxT("invalid tree item") );
  
  {
      wxCHECK_RET( itemId.IsOk(), wxT("invalid tree item") );
  
+    m_select_me = NULL;
+
      bool is_single=!(GetWindowStyleFlag() & wxTR_MULTIPLE);
      wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
  
      bool is_single=!(GetWindowStyleFlag() & wxTR_MULTIPLE);
      wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
  
@@ -1578,8 +2107,8 @@ void wxGenericTreeCtrl::SelectItem(const wxTreeItemId& itemId,
      {
          if (item->IsSelected())
              return; // nothing to do
      {
          if (item->IsSelected())
              return; // nothing to do
-        unselect_others = TRUE;
-        extended_select = FALSE;
+        unselect_others = true;
+        extended_select = false;
      }
      else if ( unselect_others && item->IsSelected() )
      {
      }
      else if ( unselect_others && item->IsSelected() )
      {
@@ -1589,26 +2118,22 @@ void wxGenericTreeCtrl::SelectItem(const wxTreeItemId& itemId,
              return;
      }
  
              return;
      }
  
-    wxTreeEvent event( wxEVT_COMMAND_TREE_SEL_CHANGING, GetId() );
-    event.m_item = (long) item;
-    event.m_itemOld = (long) m_current;
-    event.SetEventObject( this );
+    wxTreeEvent event(wxEVT_COMMAND_TREE_SEL_CHANGING, this, item);
+    event.m_itemOld = m_current;
      // TODO : Here we don't send any selection mode yet !
  
      if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() )
          return;
  
      // TODO : Here we don't send any selection mode yet !
  
      if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() )
          return;
  
-    wxTreeItemId parent = GetParent( itemId );
+    wxTreeItemId parent = GetItemParent( itemId );
      while (parent.IsOk())
      {
          if (!IsExpanded(parent))
              Expand( parent );
  
      while (parent.IsOk())
      {
          if (!IsExpanded(parent))
              Expand( parent );
  
-        parent = GetParent( parent );
+        parent = GetItemParent( parent );
      }
  
      }
  
-    EnsureVisible( itemId );
-
      // ctrl press
      if (unselect_others)
      {
      // ctrl press
      if (unselect_others)
      {
@@ -1621,7 +2146,8 @@ void wxGenericTreeCtrl::SelectItem(const wxTreeItemId& itemId,
      {
          if ( !m_current )
          {
      {
          if ( !m_current )
          {
-            m_current = m_key_current = (wxGenericTreeItem*) GetRootItem().m_pItem;
+            m_current =
+            m_key_current = (wxGenericTreeItem*) GetRootItem().m_pItem;
          }
  
          // don't change the mark (m_current)
          }
  
          // don't change the mark (m_current)
@@ -1629,7 +2155,7 @@ void wxGenericTreeCtrl::SelectItem(const wxTreeItemId& itemId,
      }
      else
      {
      }
      else
      {
-        bool select=TRUE; // the default
+        bool select = true; // the default
  
          // Check if we need to toggle hilight (ctrl mode)
          if (!unselect_others)
  
          // Check if we need to toggle hilight (ctrl mode)
          if (!unselect_others)
@@ -1640,12 +2166,41 @@ void wxGenericTreeCtrl::SelectItem(const wxTreeItemId& itemId,
          RefreshLine( m_current );
      }
  
          RefreshLine( m_current );
      }
  
+    // This can cause idle processing to select the root
+    // if no item is selected, so it must be after the
+    // selection is set
+    EnsureVisible( itemId );
+
      event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
      GetEventHandler()->ProcessEvent( event );
  }
  
      event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
      GetEventHandler()->ProcessEvent( event );
  }
  
+void wxGenericTreeCtrl::SelectItem(const wxTreeItemId& itemId, bool select)
+{
+    wxGenericTreeItem * const item = (wxGenericTreeItem*) itemId.m_pItem;
+    wxCHECK_RET( item, wxT("SelectItem(): invalid tree item") );
+
+    if ( select )
+    {
+        if ( !item->IsSelected() )
+            DoSelectItem(itemId, !HasFlag(wxTR_MULTIPLE));
+    }
+    else // deselect
+    {
+        wxTreeEvent event(wxEVT_COMMAND_TREE_SEL_CHANGING, this, item);
+        if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() )
+            return;
+
+        item->SetHilight(false);
+        RefreshLine(item);
+
+        event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
+        GetEventHandler()->ProcessEvent( event );
+    }
+}
+
  void wxGenericTreeCtrl::FillArray(wxGenericTreeItem *item,
  void wxGenericTreeCtrl::FillArray(wxGenericTreeItem *item,
-                           wxArrayTreeItemIds &array) const
+                                  wxArrayTreeItemIds &array) const
  {
      if ( item->IsSelected() )
          array.Add(wxTreeItemId(item));
  {
      if ( item->IsSelected() )
          array.Add(wxTreeItemId(item));
@@ -1669,21 +2224,35 @@ size_t wxGenericTreeCtrl::GetSelections(wxArrayTreeItemIds &array) const
      }
      //else: the tree is empty, so no selections
  
      }
      //else: the tree is empty, so no selections
  
-    return array.Count();
+    return array.GetCount();
  }
  
  void wxGenericTreeCtrl::EnsureVisible(const wxTreeItemId& item)
  {
  }
  
  void wxGenericTreeCtrl::EnsureVisible(const wxTreeItemId& item)
  {
+    wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
+
      if (!item.IsOk()) return;
  
      wxGenericTreeItem *gitem = (wxGenericTreeItem*) item.m_pItem;
  
      // first expand all parent branches
      wxGenericTreeItem *parent = gitem->GetParent();
      if (!item.IsOk()) return;
  
      wxGenericTreeItem *gitem = (wxGenericTreeItem*) item.m_pItem;
  
      // first expand all parent branches
      wxGenericTreeItem *parent = gitem->GetParent();
-    while ( parent )
+
+    if ( HasFlag(wxTR_HIDE_ROOT) )
      {
      {
-        Expand(parent);
-        parent = parent->GetParent();
+        while ( parent && parent != m_anchor )
+        {
+            Expand(parent);
+            parent = parent->GetParent();
+        }
+    }
+    else
+    {
+        while ( parent )
+        {
+            Expand(parent);
+            parent = parent->GetParent();
+        }
      }
  
      //if (parent) CalculatePositions();
      }
  
      //if (parent) CalculatePositions();
@@ -1693,52 +2262,42 @@ void wxGenericTreeCtrl::EnsureVisible(const wxTreeItemId& item)
  
  void wxGenericTreeCtrl::ScrollTo(const wxTreeItemId &item)
  {
  
  void wxGenericTreeCtrl::ScrollTo(const wxTreeItemId &item)
  {
-    if (!item.IsOk()) return;
+    if (!item.IsOk())
+        return;
  
  
-    // We have to call this here because the label in
-    // question might just have been added and no screen
-    // update taken place.
-    if (m_dirty) wxYieldIfNeeded();
+    // update the control before scrolling it
+    if (m_dirty)
+#if defined( __WXMSW__ ) || defined(__WXMAC__)
+        Update();
+#else
+        DoDirtyProcessing();
+#endif
  
      wxGenericTreeItem *gitem = (wxGenericTreeItem*) item.m_pItem;
  
  
      wxGenericTreeItem *gitem = (wxGenericTreeItem*) item.m_pItem;
  
-    // now scroll to the item
-    int item_y = gitem->GetY();
+    int itemY = gitem->GetY();
  
      int start_x = 0;
      int start_y = 0;
      GetViewStart( &start_x, &start_y );
  
      int start_x = 0;
      int start_y = 0;
      GetViewStart( &start_x, &start_y );
-    start_y *= PIXELS_PER_UNIT;
  
  
-    int client_h = 0;
-    int client_w = 0;
-    GetClientSize( &client_w, &client_h );
+    const int clientHeight = GetClientSize().y;
+
+    const int itemHeight = GetLineHeight(gitem) + 2;
  
  
-    if (item_y < start_y+3)
+    if ( itemY + itemHeight > start_y*PIXELS_PER_UNIT + clientHeight )
      {
      {
-        // going down
-        int x = 0;
-        int y = 0;
-        m_anchor->GetSize( x, y, this );
-        y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
-        x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
-        int x_pos = GetScrollPos( wxHORIZONTAL );
-        // Item should appear at top
-        SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, item_y/PIXELS_PER_UNIT );
+        // need to scroll up by enough to show this item fully
+        itemY += itemHeight - clientHeight;
      }
      }
-    else if (item_y+GetLineHeight(gitem) > start_y+client_h)
+    else if ( itemY > start_y*PIXELS_PER_UNIT )
      {
      {
-        // going up
-        int x = 0;
-        int y = 0;
-        m_anchor->GetSize( x, y, this );
-        y += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
-        x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
-        item_y += PIXELS_PER_UNIT+2;
-        int x_pos = GetScrollPos( wxHORIZONTAL );
-        // Item should appear at bottom
-        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 );
+        // item is already fully visible, don't do anything
+        return;
      }
      }
+    //else: scroll down to make this item the top one displayed
+
+    Scroll(-1, itemY/PIXELS_PER_UNIT);
  }
  
  // FIXME: tree sorting functions are not reentrant and not MT-safe!
  }
  
  // FIXME: tree sorting functions are not reentrant and not MT-safe!
@@ -1747,17 +2306,12 @@ static wxGenericTreeCtrl *s_treeBeingSorted = NULL;
  static int LINKAGEMODE tree_ctrl_compare_func(wxGenericTreeItem **item1,
                                    wxGenericTreeItem **item2)
  {
  static int LINKAGEMODE tree_ctrl_compare_func(wxGenericTreeItem **item1,
                                    wxGenericTreeItem **item2)
  {
-    wxCHECK_MSG( s_treeBeingSorted, 0, wxT("bug in wxGenericTreeCtrl::SortChildren()") );
+    wxCHECK_MSG( s_treeBeingSorted, 0,
+                 "bug in wxGenericTreeCtrl::SortChildren()" );
  
      return s_treeBeingSorted->OnCompareItems(*item1, *item2);
  }
  
  
      return s_treeBeingSorted->OnCompareItems(*item1, *item2);
  }
  
-int wxGenericTreeCtrl::OnCompareItems(const wxTreeItemId& item1,
-                               const wxTreeItemId& item2)
-{
-    return wxStrcmp(GetItemText(item1), GetItemText(item2));
-}
-
  void wxGenericTreeCtrl::SortChildren(const wxTreeItemId& itemId)
  {
      wxCHECK_RET( itemId.IsOk(), wxT("invalid tree item") );
  void wxGenericTreeCtrl::SortChildren(const wxTreeItemId& itemId)
  {
      wxCHECK_RET( itemId.IsOk(), wxT("invalid tree item") );
@@ -1768,9 +2322,9 @@ void wxGenericTreeCtrl::SortChildren(const wxTreeItemId& itemId)
                   wxT("wxGenericTreeCtrl::SortChildren is not reentrant") );
  
      wxArrayGenericTreeItems& children = item->GetChildren();
                   wxT("wxGenericTreeCtrl::SortChildren is not reentrant") );
  
      wxArrayGenericTreeItems& children = item->GetChildren();
-    if ( children.Count() > 1 )
+    if ( children.GetCount() > 1 )
      {
      {
-        m_dirty = TRUE;
+        m_dirty = true;
  
          s_treeBeingSorted = this;
          children.Sort(tree_ctrl_compare_func);
  
          s_treeBeingSorted = this;
          children.Sort(tree_ctrl_compare_func);
@@ -1779,21 +2333,6 @@ void wxGenericTreeCtrl::SortChildren(const wxTreeItemId& itemId)
      //else: don't make the tree dirty as nothing changed
  }
  
      //else: don't make the tree dirty as nothing changed
  }
  
-wxImageList *wxGenericTreeCtrl::GetImageList() const
-{
-    return m_imageListNormal;
-}
-
-wxImageList *wxGenericTreeCtrl::GetButtonsImageList() const
-{
-    return m_imageListButtons;
-}
-
-wxImageList *wxGenericTreeCtrl::GetStateImageList() const
-{
-    return m_imageListState;
-}
-
  void wxGenericTreeCtrl::CalculateLineHeight()
  {
      wxClientDC dc(this);
  void wxGenericTreeCtrl::CalculateLineHeight()
  {
      wxClientDC dc(this);
@@ -1813,6 +2352,20 @@ void wxGenericTreeCtrl::CalculateLineHeight()
          }
      }
  
          }
      }
  
+    if ( m_imageListState )
+    {
+        // Calculate a m_lineHeight value from the state Image sizes.
+        // May be toggle off. Then wxGenericTreeCtrl will spread when
+        // necessary (which might look ugly).
+        int n = m_imageListState->GetImageCount();
+        for (int i = 0; i < n ; i++)
+        {
+            int width = 0, height = 0;
+            m_imageListState->GetSize(i, width, height);
+            if (height > m_lineHeight) m_lineHeight = height;
+        }
+    }
+
      if (m_imageListButtons)
      {
          // Calculate a m_lineHeight value from the Button image sizes.
      if (m_imageListButtons)
      {
          // Calculate a m_lineHeight value from the Button image sizes.
@@ -1837,43 +2390,51 @@ void wxGenericTreeCtrl::SetImageList(wxImageList *imageList)
  {
      if (m_ownsImageListNormal) delete m_imageListNormal;
      m_imageListNormal = imageList;
  {
      if (m_ownsImageListNormal) delete m_imageListNormal;
      m_imageListNormal = imageList;
-    m_ownsImageListNormal = FALSE;
-    m_dirty = TRUE;
-    CalculateLineHeight();
+    m_ownsImageListNormal = false;
+    m_dirty = true;
+
+    if (m_anchor)
+        m_anchor->RecursiveResetSize();
+
+    // Don't do any drawing if we're setting the list to NULL,
+    // since we may be in the process of deleting the tree control.
+    if (imageList)
+        CalculateLineHeight();
  }
  
  void wxGenericTreeCtrl::SetStateImageList(wxImageList *imageList)
  {
      if (m_ownsImageListState) delete m_imageListState;
      m_imageListState = imageList;
  }
  
  void wxGenericTreeCtrl::SetStateImageList(wxImageList *imageList)
  {
      if (m_ownsImageListState) delete m_imageListState;
      m_imageListState = imageList;
-    m_ownsImageListState = FALSE;
+    m_ownsImageListState = false;
+    m_dirty = true;
+
+    if (m_anchor)
+        m_anchor->RecursiveResetSize();
+
+    // Don't do any drawing if we're setting the list to NULL,
+    // since we may be in the process of deleting the tree control.
+    if (imageList)
+        CalculateLineHeight();
  }
  
  void wxGenericTreeCtrl::SetButtonsImageList(wxImageList *imageList)
  {
      if (m_ownsImageListButtons) delete m_imageListButtons;
      m_imageListButtons = imageList;
  }
  
  void wxGenericTreeCtrl::SetButtonsImageList(wxImageList *imageList)
  {
      if (m_ownsImageListButtons) delete m_imageListButtons;
      m_imageListButtons = imageList;
-    m_ownsImageListButtons = FALSE;
-    m_dirty = TRUE;
-    CalculateLineHeight();
-}
+    m_ownsImageListButtons = false;
+    m_dirty = true;
  
  
-void wxGenericTreeCtrl::AssignImageList(wxImageList *imageList)
-{
-    SetImageList(imageList);
-    m_ownsImageListNormal = TRUE;
-}
+    if (m_anchor)
+        m_anchor->RecursiveResetSize();
  
  
-void wxGenericTreeCtrl::AssignStateImageList(wxImageList *imageList)
-{
-    SetStateImageList(imageList);
-    m_ownsImageListState = TRUE;
+    CalculateLineHeight();
  }
  
  void wxGenericTreeCtrl::AssignButtonsImageList(wxImageList *imageList)
  {
      SetButtonsImageList(imageList);
  }
  
  void wxGenericTreeCtrl::AssignButtonsImageList(wxImageList *imageList)
  {
      SetButtonsImageList(imageList);
-    m_ownsImageListButtons = TRUE;
+    m_ownsImageListButtons = true;
  }
  
  // -----------------------------------------------------------------------------
  }
  
  // -----------------------------------------------------------------------------
@@ -1890,7 +2451,9 @@ void wxGenericTreeCtrl::AdjustMyScrollbars()
          x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
          int x_pos = GetScrollPos( wxHORIZONTAL );
          int y_pos = GetScrollPos( wxVERTICAL );
          x += PIXELS_PER_UNIT+2; // one more scrollbar unit + 2 pixels
          int x_pos = GetScrollPos( wxHORIZONTAL );
          int y_pos = GetScrollPos( wxVERTICAL );
-        SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT, x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT, x_pos, y_pos );
+        SetScrollbars( PIXELS_PER_UNIT, PIXELS_PER_UNIT,
+                       x/PIXELS_PER_UNIT, y/PIXELS_PER_UNIT,
+                       x_pos, y_pos );
      }
      else
      {
      }
      else
      {
@@ -1908,16 +2471,10 @@ int wxGenericTreeCtrl::GetLineHeight(wxGenericTreeItem *item) const
  
  void wxGenericTreeCtrl::PaintItem(wxGenericTreeItem *item, wxDC& dc)
  {
  
  void wxGenericTreeCtrl::PaintItem(wxGenericTreeItem *item, wxDC& dc)
  {
-    // TODO implement "state" icon on items
+    item->SetFont(this, dc);
+    item->CalculateSize(this, dc);
  
  
-    wxTreeItemAttr *attr = item->GetAttributes();
-    if ( attr && attr->HasFont() )
-        dc.SetFont(attr->GetFont());
-    else if (item->IsBold())
-        dc.SetFont(m_boldFont);
-
-    long text_w = 0, text_h = 0;
-    dc.GetTextExtent( item->GetText(), &text_w, &text_h );
+    wxCoord text_h = item->GetTextHeight();
  
      int image_h = 0, image_w = 0;
      int image = item->GetCurrentImage();
  
      int image_h = 0, image_w = 0;
      int image = item->GetCurrentImage();
@@ -1925,8 +2482,8 @@ void wxGenericTreeCtrl::PaintItem(wxGenericTreeItem *item, wxDC& dc)
      {
          if ( m_imageListNormal )
          {
      {
          if ( m_imageListNormal )
          {
-            m_imageListNormal->GetSize( image, image_w, image_h );
-            image_w += 4;
+            m_imageListNormal->GetSize(image, image_w, image_h);
+            image_w += MARGIN_BETWEEN_IMAGE_AND_TEXT;
          }
          else
          {
          }
          else
          {
@@ -1934,71 +2491,208 @@ void wxGenericTreeCtrl::PaintItem(wxGenericTreeItem *item, wxDC& dc)
          }
      }
  
          }
      }
  
+    int state_h = 0, state_w = 0;
+    int state = item->GetState();
+    if ( state != wxTREE_ITEMSTATE_NONE )
+    {
+        if ( m_imageListState )
+        {
+            m_imageListState->GetSize(state, state_w, state_h);
+            if ( image_w != 0 )
+                state_w += MARGIN_BETWEEN_STATE_AND_IMAGE;
+            else
+                state_w += MARGIN_BETWEEN_IMAGE_AND_TEXT;
+        }
+        else
+        {
+            state = wxTREE_ITEMSTATE_NONE;
+        }
+    }
+
      int total_h = GetLineHeight(item);
      int total_h = GetLineHeight(item);
+    bool drawItemBackground = false,
+         hasBgColour = false;
  
      if ( item->IsSelected() )
      {
          dc.SetBrush(*(m_hasFocus ? m_hilightBrush : m_hilightUnfocusedBrush));
  
      if ( item->IsSelected() )
      {
          dc.SetBrush(*(m_hasFocus ? m_hilightBrush : m_hilightUnfocusedBrush));
+        drawItemBackground = true;
      }
      else
      {
          wxColour colBg;
      }
      else
      {
          wxColour colBg;
+        wxTreeItemAttr * const attr = item->GetAttributes();
          if ( attr && attr->HasBackgroundColour() )
          if ( attr && attr->HasBackgroundColour() )
+        {
+            drawItemBackground =
+            hasBgColour = true;
              colBg = attr->GetBackgroundColour();
              colBg = attr->GetBackgroundColour();
+        }
          else
          else
-            colBg = m_backgroundColour;
-        dc.SetBrush(wxBrush(colBg, wxSOLID));
+        {
+            colBg = GetBackgroundColour();
+        }
+        dc.SetBrush(wxBrush(colBg, wxBRUSHSTYLE_SOLID));
      }
  
      int offset = HasFlag(wxTR_ROW_LINES) ? 1 : 0;
  
      if ( HasFlag(wxTR_FULL_ROW_HIGHLIGHT) )
      {
      }
  
      int offset = HasFlag(wxTR_ROW_LINES) ? 1 : 0;
  
      if ( HasFlag(wxTR_FULL_ROW_HIGHLIGHT) )
      {
-        int x, y, w, h;
+        int x, w, h;
+        x=0;
+        GetVirtualSize(&w, &h);
+        wxRect rect( x, item->GetY()+offset, w, total_h-offset);
+        if (!item->IsSelected())
+        {
+            dc.DrawRectangle(rect);
+        }
+        else
+        {
+            int flags = wxCONTROL_SELECTED;
+            if (m_hasFocus
+#if defined( __WXMAC__ ) && !defined(__WXUNIVERSAL__) && wxOSX_USE_CARBON // TODO CS
+                && IsControlActive( (ControlRef)GetHandle() )
+#endif
+            )
+                flags |= wxCONTROL_FOCUSED;
+            if ((item == m_current) && (m_hasFocus))
+                flags |= wxCONTROL_CURRENT;
  
  
-        DoGetPosition(&x, &y);
-        DoGetSize(&w, &h);
-        dc.DrawRectangle(x, item->GetY()+offset, w, total_h-offset);
+            wxRendererNative::Get().
+                DrawItemSelectionRect(this, dc, rect, flags);
+        }
      }
      }
-    else
+    else // no full row highlight
      {
      {
-        if ( item->IsSelected() && image != NO_IMAGE )
+        if ( item->IsSelected() &&
+                (state != wxTREE_ITEMSTATE_NONE || image != NO_IMAGE) )
          {
          {
-            // If it's selected, and there's an image, then we should
-            // take care to leave the area under the image painted in the
-            // background colour.
-            dc.DrawRectangle( item->GetX() + image_w - 2, item->GetY()+offset,
-                              item->GetWidth() - image_w + 2, total_h-offset );
+            // If it's selected, and there's an state image or normal image,
+            // then we should take care to leave the area under the image
+            // painted in the background colour.
+            wxRect rect( item->GetX() + state_w + image_w - 2,
+                         item->GetY() + offset,
+                         item->GetWidth() - state_w - image_w + 2,
+                         total_h - offset );
+#if !defined(__WXGTK20__) && !defined(__WXMAC__)
+            dc.DrawRectangle( rect );
+#else
+            rect.x -= 1;
+            rect.width += 2;
+
+            int flags = wxCONTROL_SELECTED;
+            if (m_hasFocus)
+                flags |= wxCONTROL_FOCUSED;
+            if ((item == m_current) && (m_hasFocus))
+                flags |= wxCONTROL_CURRENT;
+            wxRendererNative::Get().
+                DrawItemSelectionRect(this, dc, rect, flags);
+#endif
          }
          }
-        else
+        // On GTK+ 2, drawing a 'normal' background is wrong for themes that
+        // don't allow backgrounds to be customized. Not drawing the background,
+        // except for custom item backgrounds, works for both kinds of theme.
+        else if (drawItemBackground)
          {
          {
-            dc.DrawRectangle( item->GetX()-2, item->GetY()+offset,
-                              item->GetWidth()+2, total_h-offset );
+            wxRect rect( item->GetX() + state_w + image_w - 2,
+                         item->GetY() + offset,
+                         item->GetWidth() - state_w - image_w + 2,
+                         total_h - offset );
+            if ( hasBgColour )
+            {
+                dc.DrawRectangle( rect );
+            }
+            else // no specific background colour
+            {
+                rect.x -= 1;
+                rect.width += 2;
+
+                int flags = wxCONTROL_SELECTED;
+                if (m_hasFocus)
+                    flags |= wxCONTROL_FOCUSED;
+                if ((item == m_current) && (m_hasFocus))
+                    flags |= wxCONTROL_CURRENT;
+                wxRendererNative::Get().
+                    DrawItemSelectionRect(this, dc, rect, flags);
+            }
          }
      }
  
          }
      }
  
+    if ( state != wxTREE_ITEMSTATE_NONE )
+    {
+        dc.SetClippingRegion( item->GetX(), item->GetY(), state_w, total_h );
+        m_imageListState->Draw( state, dc,
+                                item->GetX(),
+                                item->GetY() +
+                                    (total_h > state_h ? (total_h-state_h)/2
+                                                       : 0),
+                                wxIMAGELIST_DRAW_TRANSPARENT );
+        dc.DestroyClippingRegion();
+    }
+
      if ( image != NO_IMAGE )
      {
      if ( image != NO_IMAGE )
      {
-        dc.SetClippingRegion( item->GetX(), item->GetY(), image_w-2, total_h );
+        dc.SetClippingRegion(item->GetX() + state_w, item->GetY(),
+                             image_w, total_h);
          m_imageListNormal->Draw( image, dc,
          m_imageListNormal->Draw( image, dc,
-                                 item->GetX(),
-                                 item->GetY() +((total_h > image_h)?((total_h-image_h)/2):0),
+                                 item->GetX() + state_w,
+                                 item->GetY() +
+                                    (total_h > image_h ? (total_h-image_h)/2
+                                                       : 0),
                                   wxIMAGELIST_DRAW_TRANSPARENT );
          dc.DestroyClippingRegion();
      }
  
                                   wxIMAGELIST_DRAW_TRANSPARENT );
          dc.DestroyClippingRegion();
      }
  
-    dc.SetBackgroundMode(wxTRANSPARENT);
+    dc.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);
      int extraH = (total_h > text_h) ? (total_h - text_h)/2 : 0;
      dc.DrawText( item->GetText(),
      int extraH = (total_h > text_h) ? (total_h - text_h)/2 : 0;
      dc.DrawText( item->GetText(),
-                 (wxCoord)(image_w + item->GetX()),
+                 (wxCoord)(state_w + image_w + item->GetX()),
                   (wxCoord)(item->GetY() + extraH));
  
      // restore normal font
      dc.SetFont( m_normalFont );
                   (wxCoord)(item->GetY() + extraH));
  
      // restore normal font
      dc.SetFont( m_normalFont );
+
+    if (item == m_dndEffectItem)
+    {
+        dc.SetPen( *wxBLACK_PEN );
+        // DnD visual effects
+        switch (m_dndEffect)
+        {
+            case BorderEffect:
+            {
+                dc.SetBrush(*wxTRANSPARENT_BRUSH);
+                int w = item->GetWidth() + 2;
+                int h = total_h + 2;
+                dc.DrawRectangle( item->GetX() - 1, item->GetY() - 1, w, h);
+                break;
+            }
+            case AboveEffect:
+            {
+                int x = item->GetX(),
+                    y = item->GetY();
+                dc.DrawLine( x, y, x + item->GetWidth(), y);
+                break;
+            }
+            case BelowEffect:
+            {
+                int x = item->GetX(),
+                    y = item->GetY();
+                y += total_h - 1;
+                dc.DrawLine( x, y, x + item->GetWidth(), y);
+                break;
+            }
+            case NoEffect:
+                break;
+        }
+    }
  }
  
  }
  
-// Now y stands for the top of the item, whereas it used to stand for middle !
-void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y )
+void
+wxGenericTreeCtrl::PaintLevel(wxGenericTreeItem *item,
+                              wxDC &dc,
+                              int level,
+                              int &y)
  {
      int x = level*m_indent;
      if (!HasFlag(wxTR_HIDE_ROOT))
  {
      int x = level*m_indent;
      if (!HasFlag(wxTR_HIDE_ROOT))
@@ -2010,7 +2704,7 @@ void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level
          // always expand hidden root
          int origY = y;
          wxArrayGenericTreeItems& children = item->GetChildren();
          // always expand hidden root
          int origY = y;
          wxArrayGenericTreeItems& children = item->GetChildren();
-        int count = children.Count();
+        int count = children.GetCount();
          if (count > 0)
          {
              int n = 0, oldY;
          if (count > 0)
          {
              int n = 0, oldY;
@@ -2019,7 +2713,8 @@ void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level
                  PaintLevel(children[n], dc, 1, y);
              } while (++n < count);
  
                  PaintLevel(children[n], dc, 1, y);
              } while (++n < count);
  
-            if (!HasFlag(wxTR_NO_LINES) && HasFlag(wxTR_LINES_AT_ROOT) && count > 0)
+            if ( !HasFlag(wxTR_NO_LINES) && HasFlag(wxTR_LINES_AT_ROOT)
+                    && count > 0 )
              {
                  // draw line down to last child
                  origY += GetLineHeight(children[0])>>1;
              {
                  // draw line down to last child
                  origY += GetLineHeight(children[0])>>1;
@@ -2043,7 +2738,7 @@ void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level
  
      if (IsExposed(exposed_x, exposed_y, 10000, h))  // 10000 = very much
      {
  
      if (IsExposed(exposed_x, exposed_y, 10000, h))  // 10000 = very much
      {
-        wxPen *pen =
+        const wxPen *pen =
  #ifndef __WXMAC__
              // don't draw rect outline if we already have the
              // background color under Mac
  #ifndef __WXMAC__
              // don't draw rect outline if we already have the
              // background color under Mac
@@ -2052,9 +2747,24 @@ void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level
              wxTRANSPARENT_PEN;
  
          wxColour colText;
              wxTRANSPARENT_PEN;
  
          wxColour colText;
-        if ( item->IsSelected() )
+        if ( item->IsSelected()
+#if defined( __WXMAC__ ) && !defined(__WXUNIVERSAL__) && wxOSX_USE_CARBON // TODO CS
+            // On wxMac, if the tree doesn't have the focus we draw an empty
+            // rectangle, so we want to make sure that the text is visible
+            // against the normal background, not the highlightbackground, so
+            // don't use the highlight text colour unless we have the focus.
+             && m_hasFocus && IsControlActive( (ControlRef)GetHandle() )
+#endif
+            )
          {
          {
-            colText = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
+#ifdef __WXMAC__
+            colText = *wxWHITE;
+#else
+            if (m_hasFocus)
+                colText = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
+            else
+                colText = wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOXHIGHLIGHTTEXT);
+#endif
          }
          else
          {
          }
          else
          {
@@ -2087,85 +2797,7 @@ void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level
          dc.SetPen(m_dottedPen);
          dc.SetTextForeground(*wxBLACK);
  
          dc.SetPen(m_dottedPen);
          dc.SetTextForeground(*wxBLACK);
  
-        if (item->HasPlus() && HasButtons())  // should the item show a button?
-        {
-            if (!HasFlag(wxTR_NO_LINES))
-            {
-                if (x > (signed)m_indent)
-                    dc.DrawLine(x - m_indent, y_mid, x - 5, y_mid);
-                else if (HasFlag(wxTR_LINES_AT_ROOT))
-                    dc.DrawLine(3, y_mid, x - 5, y_mid);
-                dc.DrawLine(x + 5, y_mid, x + m_spacing, y_mid);
-            }
-
-            if (m_imageListButtons != NULL)
-            {
-                // draw the image button here
-                int image_h = 0, image_w = 0, image = wxTreeItemIcon_Normal;
-                if (item->IsExpanded()) image = wxTreeItemIcon_Expanded;
-                if (item->IsSelected())
-                    image += wxTreeItemIcon_Selected - wxTreeItemIcon_Normal;
-                m_imageListButtons->GetSize(image, image_w, image_h);
-                int xx = x - (image_w>>1);
-                int yy = y_mid - (image_h>>1);
-                dc.SetClippingRegion(xx, yy, image_w, image_h);
-                m_imageListButtons->Draw(image, dc, xx, yy,
-                                         wxIMAGELIST_DRAW_TRANSPARENT);
-                dc.DestroyClippingRegion();
-            }
-            else if (HasFlag(wxTR_TWIST_BUTTONS))
-            {
-                // draw the twisty button here
-
-                if (HasFlag(wxTR_AQUA_BUTTONS))
-                {
-                    if (item->IsExpanded())
-                        dc.DrawBitmap( *m_arrowDown, x-5, y_mid-6, TRUE );
-                    else
-                        dc.DrawBitmap( *m_arrowRight, x-5, y_mid-6, TRUE );
-                }
-                else
-                {
-                    dc.SetBrush(*m_hilightBrush);
-                    dc.SetPen(*wxBLACK_PEN);
-                    wxPoint button[3];
-
-                    if (item->IsExpanded())
-                    {
-                        button[0].x = x-5;
-                        button[0].y = y_mid-2;
-                        button[1].x = x+5;
-                        button[1].y = y_mid-2;
-                        button[2].x = x;
-                        button[2].y = y_mid+3;
-                    }
-                    else
-                    {
-                        button[0].y = y_mid-5;
-                        button[0].x = x-2;
-                        button[1].y = y_mid+5;
-                        button[1].x = x-2;
-                        button[2].y = y_mid;
-                        button[2].x = x+3;
-                    }
-                    dc.DrawPolygon(3, button);
-                    dc.SetPen(m_dottedPen);
-                }
-            }
-            else // if (HasFlag(wxTR_HAS_BUTTONS))
-            {
-                // draw the plus sign here
-                dc.SetPen(*wxGREY_PEN);
-                dc.SetBrush(*wxWHITE_BRUSH);
-                dc.DrawRectangle(x-5, y_mid-4, 11, 9);
-                dc.SetPen(*wxBLACK_PEN);
-                dc.DrawLine(x-2, y_mid, x+3, y_mid);
-                if (!item->IsExpanded())
-                    dc.DrawLine(x, y_mid-2, x, y_mid+3);
-                dc.SetPen(m_dottedPen);
-            }
-        }
-        else if (!HasFlag(wxTR_NO_LINES))  // no button; maybe a line?
+        if ( !HasFlag(wxTR_NO_LINES) )
          {
              // draw the horizontal line here
              int x_start = x;
          {
              // draw the horizontal line here
              int x_start = x;
@@ -2175,12 +2807,56 @@ void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level
                  x_start = 3;
              dc.DrawLine(x_start, y_mid, x + m_spacing, y_mid);
          }
                  x_start = 3;
              dc.DrawLine(x_start, y_mid, x + m_spacing, y_mid);
          }
+
+        // should the item show a button?
+        if ( item->HasPlus() && HasButtons() )
+        {
+            if ( m_imageListButtons )
+            {
+                // draw the image button here
+                int image_h = 0,
+                    image_w = 0;
+                int image = item->IsExpanded() ? wxTreeItemIcon_Expanded
+                                               : wxTreeItemIcon_Normal;
+                if ( item->IsSelected() )
+                    image += wxTreeItemIcon_Selected - wxTreeItemIcon_Normal;
+
+                m_imageListButtons->GetSize(image, image_w, image_h);
+                int xx = x - image_w/2;
+                int yy = y_mid - image_h/2;
+
+                wxDCClipper clip(dc, xx, yy, image_w, image_h);
+                m_imageListButtons->Draw(image, dc, xx, yy,
+                                         wxIMAGELIST_DRAW_TRANSPARENT);
+            }
+            else // no custom buttons
+            {
+                static const int wImage = 9;
+                static const int hImage = 9;
+
+                int flag = 0;
+                if (item->IsExpanded())
+                    flag |= wxCONTROL_EXPANDED;
+                if (item == m_underMouse)
+                    flag |= wxCONTROL_CURRENT;
+
+                wxRendererNative::Get().DrawTreeItemButton
+                                        (
+                                            this,
+                                            dc,
+                                            wxRect(x - wImage/2,
+                                                   y_mid - hImage/2,
+                                                   wImage, hImage),
+                                            flag
+                                        );
+            }
+        }
      }
  
      if (item->IsExpanded())
      {
          wxArrayGenericTreeItems& children = item->GetChildren();
      }
  
      if (item->IsExpanded())
      {
          wxArrayGenericTreeItems& children = item->GetChildren();
-        int count = children.Count();
+        int count = children.GetCount();
          if (count > 0)
          {
              int n = 0, oldY;
          if (count > 0)
          {
              int n = 0, oldY;
@@ -2195,7 +2871,24 @@ void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level
                  // draw line down to last child
                  oldY += GetLineHeight(children[n-1])>>1;
                  if (HasButtons()) y_mid += 5;
                  // draw line down to last child
                  oldY += GetLineHeight(children[n-1])>>1;
                  if (HasButtons()) y_mid += 5;
-                dc.DrawLine(x, y_mid, x, oldY);
+
+                // Only draw the portion of the line that is visible, in case
+                // it is huge
+                wxCoord xOrigin=0, yOrigin=0, width, height;
+                dc.GetDeviceOrigin(&xOrigin, &yOrigin);
+                yOrigin = abs(yOrigin);
+                GetClientSize(&width, &height);
+
+                // Move end points to the beginning/end of the view?
+                if (y_mid < yOrigin)
+                    y_mid = yOrigin;
+                if (oldY > yOrigin + height)
+                    oldY = yOrigin + height;
+
+                // after the adjustments if y_mid is larger than oldY then the
+                // line isn't visible at all so don't draw anything
+                if (y_mid < oldY)
+                    dc.DrawLine(x, y_mid, x, oldY);
              }
          }
      }
              }
          }
      }
@@ -2214,10 +2907,10 @@ void wxGenericTreeCtrl::DrawDropEffect(wxGenericTreeItem *item)
          {
              // draw a line under the drop target because the item will be
              // dropped there
          {
              // draw a line under the drop target because the item will be
              // dropped there
-            DrawLine(item, TRUE /* below */);
+            DrawLine(item, !m_dropEffectAboveItem );
          }
  
          }
  
-        SetCursor(wxCURSOR_BULLSEYE);
+        SetCursor(*wxSTANDARD_CURSOR);
      }
      else
      {
      }
      else
      {
@@ -2228,45 +2921,65 @@ void wxGenericTreeCtrl::DrawDropEffect(wxGenericTreeItem *item)
  
  void wxGenericTreeCtrl::DrawBorder(const wxTreeItemId &item)
  {
  
  void wxGenericTreeCtrl::DrawBorder(const wxTreeItemId &item)
  {
-    wxCHECK_RET( item.IsOk(), _T("invalid item in wxGenericTreeCtrl::DrawLine") );
+    wxCHECK_RET( item.IsOk(), "invalid item in wxGenericTreeCtrl::DrawLine" );
  
      wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
  
  
      wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
  
-    wxClientDC dc(this);
-    PrepareDC( dc );
-    dc.SetLogicalFunction(wxINVERT);
-    dc.SetBrush(*wxTRANSPARENT_BRUSH);
-
-    int w = i->GetWidth() + 2;
-    int h = GetLineHeight(i) + 2;
+    if (m_dndEffect == NoEffect)
+    {
+        m_dndEffect = BorderEffect;
+        m_dndEffectItem = i;
+    }
+    else
+    {
+        m_dndEffect = NoEffect;
+        m_dndEffectItem = NULL;
+    }
  
  
-    dc.DrawRectangle( i->GetX() - 1, i->GetY() - 1, w, h);
+    wxRect rect( i->GetX()-1, i->GetY()-1, i->GetWidth()+2, GetLineHeight(i)+2 );
+    CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
+    RefreshRect( rect );
  }
  
  void wxGenericTreeCtrl::DrawLine(const wxTreeItemId &item, bool below)
  {
  }
  
  void wxGenericTreeCtrl::DrawLine(const wxTreeItemId &item, bool below)
  {
-    wxCHECK_RET( item.IsOk(), _T("invalid item in wxGenericTreeCtrl::DrawLine") );
+    wxCHECK_RET( item.IsOk(), "invalid item in wxGenericTreeCtrl::DrawLine" );
  
      wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
  
  
      wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
  
-    wxClientDC dc(this);
-    PrepareDC( dc );
-    dc.SetLogicalFunction(wxINVERT);
-
-    int x = i->GetX(),
-        y = i->GetY();
-    if ( below )
+    if (m_dndEffect == NoEffect)
+    {
+        if (below)
+            m_dndEffect = BelowEffect;
+        else
+            m_dndEffect = AboveEffect;
+        m_dndEffectItem = i;
+    }
+    else
      {
      {
-        y += GetLineHeight(i) - 1;
+        m_dndEffect = NoEffect;
+        m_dndEffectItem = NULL;
      }
  
      }
  
-    dc.DrawLine( x, y, x + i->GetWidth(), y);
+    wxRect rect( i->GetX()-1, i->GetY()-1, i->GetWidth()+2, GetLineHeight(i)+2 );
+    CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
+    RefreshRect( rect );
  }
  
  // -----------------------------------------------------------------------------
  }
  
  // -----------------------------------------------------------------------------
-// wxWindows callbacks
+// wxWidgets callbacks
  // -----------------------------------------------------------------------------
  
  // -----------------------------------------------------------------------------
  
+void wxGenericTreeCtrl::OnSize( wxSizeEvent &event )
+{
+#ifdef __WXGTK__
+    if (HasFlag( wxTR_FULL_ROW_HIGHLIGHT) && m_current)
+        RefreshLine( m_current );
+#endif
+
+    event.Skip(true);
+}
+
  void wxGenericTreeCtrl::OnPaint( wxPaintEvent &WXUNUSED(event) )
  {
      wxPaintDC dc(this);
  void wxGenericTreeCtrl::OnPaint( wxPaintEvent &WXUNUSED(event) )
  {
      wxPaintDC dc(this);
@@ -2288,7 +3001,7 @@ void wxGenericTreeCtrl::OnPaint( wxPaintEvent &WXUNUSED(event) )
  
  void wxGenericTreeCtrl::OnSetFocus( wxFocusEvent &event )
  {
  
  void wxGenericTreeCtrl::OnSetFocus( wxFocusEvent &event )
  {
-    m_hasFocus = TRUE;
+    m_hasFocus = true;
  
      RefreshSelected();
  
  
      RefreshSelected();
  
@@ -2297,24 +3010,26 @@ void wxGenericTreeCtrl::OnSetFocus( wxFocusEvent &event )
  
  void wxGenericTreeCtrl::OnKillFocus( wxFocusEvent &event )
  {
  
  void wxGenericTreeCtrl::OnKillFocus( wxFocusEvent &event )
  {
-    m_hasFocus = FALSE;
+    m_hasFocus = false;
  
      RefreshSelected();
  
      event.Skip();
  }
  
  
      RefreshSelected();
  
      event.Skip();
  }
  
-void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
+void wxGenericTreeCtrl::OnKeyDown( wxKeyEvent &event )
  {
  {
-    wxTreeEvent te( wxEVT_COMMAND_TREE_KEY_DOWN, GetId() );
+    // send a tree event
+    wxTreeEvent te( wxEVT_COMMAND_TREE_KEY_DOWN, this);
      te.m_evtKey = event;
      te.m_evtKey = event;
-    te.SetEventObject( this );
      if ( GetEventHandler()->ProcessEvent( te ) )
      if ( GetEventHandler()->ProcessEvent( te ) )
-    {
-        // intercepted by the user code
          return;
          return;
-    }
  
  
+    event.Skip();
+}
+
+void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
+{
      if ( (m_current == 0) || (m_key_current == 0) )
      {
          event.Skip();
      if ( (m_current == 0) || (m_key_current == 0) )
      {
          event.Skip();
@@ -2325,9 +3040,17 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
      bool is_multiple, extended_select, unselect_others;
      EventFlagsToSelType(GetWindowStyleFlag(),
                          event.ShiftDown(),
      bool is_multiple, extended_select, unselect_others;
      EventFlagsToSelType(GetWindowStyleFlag(),
                          event.ShiftDown(),
-                        event.ControlDown(),
+                        event.CmdDown(),
                          is_multiple, extended_select, unselect_others);
  
                          is_multiple, extended_select, unselect_others);
  
+    if (GetLayoutDirection() == wxLayout_RightToLeft)
+    {
+        if (event.GetKeyCode() == WXK_RIGHT)
+            event.m_keyCode = WXK_LEFT;
+        else if (event.GetKeyCode() == WXK_LEFT)
+            event.m_keyCode = WXK_RIGHT;
+    }
+
      // + : Expand
      // - : Collaspe
      // * : Expand all/Collapse all
      // + : Expand
      // - : Collaspe
      // * : Expand all/Collapse all
@@ -2338,7 +3061,24 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
      // right : open if parent and go next
      // home  : go to root
      // end   : go to last item without opening parents
      // right : open if parent and go next
      // home  : go to root
      // end   : go to last item without opening parents
-    switch (event.KeyCode())
+    // alnum : start or continue searching for the item with this prefix
+    int keyCode = event.GetKeyCode();
+
+#ifdef __WXOSX__
+    // Make the keys work as they do in the native control:
+    // right => expand
+    // left => collapse if current item is expanded
+    if (keyCode == WXK_RIGHT)
+    {
+        keyCode = '+';
+    }
+    else if (keyCode == WXK_LEFT && IsExpanded(m_current))
+    {
+        keyCode = '-';
+    }
+#endif // __WXOSX__
+
+    switch ( keyCode )
      {
          case '+':
          case WXK_ADD:
      {
          case '+':
          case WXK_ADD:
@@ -2353,7 +3093,7 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
              if ( !IsExpanded(m_current) )
              {
                  // expand all
              if ( !IsExpanded(m_current) )
              {
                  // expand all
-                ExpandAll(m_current);
+                ExpandAllChildren(m_current);
                  break;
              }
              //else: fall through to Collapse() it
                  break;
              }
              //else: fall through to Collapse() it
@@ -2366,14 +3106,38 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
              }
              break;
  
              }
              break;
  
+        case WXK_MENU:
+            {
+                // Use the item's bounding rectangle to determine position for
+                // the event
+                wxRect ItemRect;
+                GetBoundingRect(m_current, ItemRect, true);
+
+                wxTreeEvent
+                    eventMenu(wxEVT_COMMAND_TREE_ITEM_MENU, this, m_current);
+                // Use the left edge, vertical middle
+                eventMenu.m_pointDrag = wxPoint(ItemRect.GetX(),
+                                                ItemRect.GetY() +
+                                                    ItemRect.GetHeight() / 2);
+                GetEventHandler()->ProcessEvent( eventMenu );
+            }
+            break;
+
          case ' ':
          case WXK_RETURN:
          case ' ':
          case WXK_RETURN:
+            if ( !event.HasModifiers() )
              {
              {
-                wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
-                event.m_item = (long) m_current;
-                event.SetEventObject( this );
-                GetEventHandler()->ProcessEvent( event );
+                wxTreeEvent
+                   eventAct(wxEVT_COMMAND_TREE_ITEM_ACTIVATED, this, m_current);
+                GetEventHandler()->ProcessEvent( eventAct );
              }
              }
+
+            // in any case, also generate the normal key event for this key,
+            // even if we generated the ACTIVATED event above: this is what
+            // wxMSW does and it makes sense because you might not want to
+            // process ACTIVATED event at all and handle Space and Return
+            // directly (and differently) which would be impossible otherwise
+            event.Skip();
              break;
  
              // up goes to the previous sibling or to the last
              break;
  
              // up goes to the previous sibling or to the last
@@ -2383,22 +3147,24 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
                  wxTreeItemId prev = GetPrevSibling( m_key_current );
                  if (!prev)
                  {
                  wxTreeItemId prev = GetPrevSibling( m_key_current );
                  if (!prev)
                  {
-                    prev = GetParent( m_key_current );
+                    prev = GetItemParent( m_key_current );
                      if ((prev == GetRootItem()) && HasFlag(wxTR_HIDE_ROOT))
                      {
                          break;  // don't go to root if it is hidden
                      }
                      if (prev)
                      {
                      if ((prev == GetRootItem()) && HasFlag(wxTR_HIDE_ROOT))
                      {
                          break;  // don't go to root if it is hidden
                      }
                      if (prev)
                      {
-                        long cookie = 0;
+                        wxTreeItemIdValue cookie;
                          wxTreeItemId current = m_key_current;
                          wxTreeItemId current = m_key_current;
-                        // TODO: Huh?  If we get here, we'd better be the first child of our parent.  How else could it be?
+                        // TODO: Huh?  If we get here, we'd better be the first
+                        // child of our parent.  How else could it be?
                          if (current == GetFirstChild( prev, cookie ))
                          {
                              // otherwise we return to where we came from
                          if (current == GetFirstChild( prev, cookie ))
                          {
                              // otherwise we return to where we came from
-                            SelectItem( prev, unselect_others, extended_select );
-                            m_key_current= (wxGenericTreeItem*) prev.m_pItem;
-                            EnsureVisible( prev );
+                            DoSelectItem(prev,
+                                         unselect_others,
+                                         extended_select);
+                            m_key_current = (wxGenericTreeItem*) prev.m_pItem;
                              break;
                          }
                      }
                              break;
                          }
                      }
@@ -2414,9 +3180,8 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
                          }
                      }
  
                          }
                      }
  
-                    SelectItem( prev, unselect_others, extended_select );
+                    DoSelectItem( prev, unselect_others, extended_select );
                      m_key_current=(wxGenericTreeItem*) prev.m_pItem;
                      m_key_current=(wxGenericTreeItem*) prev.m_pItem;
-                    EnsureVisible( prev );
                  }
              }
              break;
                  }
              }
              break;
@@ -2424,7 +3189,7 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
              // left arrow goes to the parent
          case WXK_LEFT:
              {
              // left arrow goes to the parent
          case WXK_LEFT:
              {
-                wxTreeItemId prev = GetParent( m_current );
+                wxTreeItemId prev = GetItemParent( m_current );
                  if ((prev == GetRootItem()) && HasFlag(wxTR_HIDE_ROOT))
                  {
                      // don't go to root if it is hidden
                  if ((prev == GetRootItem()) && HasFlag(wxTR_HIDE_ROOT))
                  {
                      // don't go to root if it is hidden
@@ -2432,8 +3197,7 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
                  }
                  if (prev)
                  {
                  }
                  if (prev)
                  {
-                    EnsureVisible( prev );
-                    SelectItem( prev, unselect_others, extended_select );
+                    DoSelectItem( prev, unselect_others, extended_select );
                  }
              }
              break;
                  }
              }
              break;
@@ -2441,18 +3205,24 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
          case WXK_RIGHT:
              // this works the same as the down arrow except that we
              // also expand the item if it wasn't expanded yet
          case WXK_RIGHT:
              // this works the same as the down arrow except that we
              // also expand the item if it wasn't expanded yet
-            Expand(m_current);
+            if (m_current != GetRootItem().m_pItem || !HasFlag(wxTR_HIDE_ROOT))
+                Expand(m_current);
+            //else: don't try to expand hidden root item (which can be the
+            //      current one when the tree is empty)
+
              // fall through
  
          case WXK_DOWN:
              {
                  if (IsExpanded(m_key_current) && HasChildren(m_key_current))
                  {
              // fall through
  
          case WXK_DOWN:
              {
                  if (IsExpanded(m_key_current) && HasChildren(m_key_current))
                  {
-                    long cookie = 0;
+                    wxTreeItemIdValue cookie;
                      wxTreeItemId child = GetFirstChild( m_key_current, cookie );
                      wxTreeItemId child = GetFirstChild( m_key_current, cookie );
-                    SelectItem( child, unselect_others, extended_select );
+                    if ( !child )
+                        break;
+
+                    DoSelectItem( child, unselect_others, extended_select );
                      m_key_current=(wxGenericTreeItem*) child.m_pItem;
                      m_key_current=(wxGenericTreeItem*) child.m_pItem;
-                    EnsureVisible( child );
                  }
                  else
                  {
                  }
                  else
                  {
@@ -2460,17 +3230,16 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
                      if (!next)
                      {
                          wxTreeItemId current = m_key_current;
                      if (!next)
                      {
                          wxTreeItemId current = m_key_current;
-                        while (current && !next)
+                        while (current.IsOk() && !next)
                          {
                          {
-                            current = GetParent( current );
+                            current = GetItemParent( current );
                              if (current) next = GetNextSibling( current );
                          }
                      }
                      if (next)
                      {
                              if (current) next = GetNextSibling( current );
                          }
                      }
                      if (next)
                      {
-                        SelectItem( next, unselect_others, extended_select );
+                        DoSelectItem( next, unselect_others, extended_select );
                          m_key_current=(wxGenericTreeItem*) next.m_pItem;
                          m_key_current=(wxGenericTreeItem*) next.m_pItem;
-                        EnsureVisible( next );
                      }
                  }
              }
                      }
                  }
              }
@@ -2487,7 +3256,7 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
  
                      // it may happen if the item was expanded but then all of
                      // its children have been deleted - so IsExpanded() returned
  
                      // it may happen if the item was expanded but then all of
                      // its children have been deleted - so IsExpanded() returned
-                    // TRUE, but GetLastChild() returned invalid item
+                    // true, but GetLastChild() returned invalid item
                      if ( !lastChild )
                          break;
  
                      if ( !lastChild )
                          break;
  
@@ -2496,8 +3265,7 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
  
                  if ( last.IsOk() )
                  {
  
                  if ( last.IsOk() )
                  {
-                    EnsureVisible( last );
-                    SelectItem( last, unselect_others, extended_select );
+                    DoSelectItem( last, unselect_others, extended_select );
                  }
              }
              break;
                  }
              }
              break;
@@ -2506,28 +3274,62 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
          case WXK_HOME:
              {
                  wxTreeItemId prev = GetRootItem();
          case WXK_HOME:
              {
                  wxTreeItemId prev = GetRootItem();
-                if (!prev) break;
-                if (HasFlag(wxTR_HIDE_ROOT))
+                if (!prev)
+                    break;
+
+                if ( HasFlag(wxTR_HIDE_ROOT) )
                  {
                  {
-                    long dummy;
-                    prev = GetFirstChild(prev, dummy);
-                    if (!prev) break;
+                    wxTreeItemIdValue cookie;
+                    prev = GetFirstChild(prev, cookie);
+                    if (!prev)
+                        break;
                  }
                  }
-                EnsureVisible( prev );
-                SelectItem( prev, unselect_others, extended_select );
+
+                DoSelectItem( prev, unselect_others, extended_select );
              }
              break;
  
          default:
              }
              break;
  
          default:
-            event.Skip();
+            // do not use wxIsalnum() here
+            if ( !event.HasModifiers() &&
+                 ((keyCode >= '0' && keyCode <= '9') ||
+                  (keyCode >= 'a' && keyCode <= 'z') ||
+                  (keyCode >= 'A' && keyCode <= 'Z' )))
+            {
+                // find the next item starting with the given prefix
+                wxChar ch = (wxChar)keyCode;
+
+                wxTreeItemId id = FindItem(m_current, m_findPrefix + ch);
+                if ( !id.IsOk() )
+                {
+                    // no such item
+                    break;
+                }
+
+                SelectItem(id);
+
+                m_findPrefix += ch;
+
+                // also start the timer to reset the current prefix if the user
+                // doesn't press any more alnum keys soon -- we wouldn't want
+                // to use this prefix for a new item search
+                if ( !m_findTimer )
+                {
+                    m_findTimer = new wxTreeFindTimer(this);
+                }
+
+                m_findTimer->Start(wxTreeFindTimer::DELAY, wxTIMER_ONE_SHOT);
+            }
+            else
+            {
+                event.Skip();
+            }
      }
  }
  
      }
  }
  
-wxTreeItemId wxGenericTreeCtrl::HitTest(const wxPoint& point, int& flags)
+wxTreeItemId
+wxGenericTreeCtrl::DoTreeHitTest(const wxPoint& point, int& flags) const
  {
  {
-    // JACS: removed wxYieldIfNeeded() because it can cause the window
-    // to be deleted from under us if a close window event is pending
-
      int w, h;
      GetSize(&w, &h);
      flags=0;
      int w, h;
      GetSize(&w, &h);
      flags=0;
@@ -2543,14 +3345,8 @@ wxTreeItemId wxGenericTreeCtrl::HitTest(const wxPoint& point, int& flags)
          return wxTreeItemId();
      }
  
          return wxTreeItemId();
      }
  
-    wxClientDC dc(this);
-    PrepareDC(dc);
-    wxCoord x = dc.DeviceToLogicalX( point.x );
-    wxCoord y = dc.DeviceToLogicalY( point.y );
-    wxGenericTreeItem *hit =  m_anchor->HitTest(wxPoint(x, y),
-                                                this,
-                                                flags,
-                                                0 );
+    wxGenericTreeItem *hit =  m_anchor->HitTest(CalcUnscrolledPosition(point),
+                                                this, flags, 0);
      if (hit == NULL)
      {
          flags = wxTREE_HITTEST_NOWHERE;
      if (hit == NULL)
      {
          flags = wxTREE_HITTEST_NOWHERE;
@@ -2561,113 +3357,196 @@ wxTreeItemId wxGenericTreeCtrl::HitTest(const wxPoint& point, int& flags)
  
  // get the bounding rectangle of the item (or of its label only)
  bool wxGenericTreeCtrl::GetBoundingRect(const wxTreeItemId& item,
  
  // get the bounding rectangle of the item (or of its label only)
  bool wxGenericTreeCtrl::GetBoundingRect(const wxTreeItemId& item,
-                         wxRect& rect,
-                         bool WXUNUSED(textOnly)) const
+                                        wxRect& rect,
+                                        bool textOnly) const
  {
  {
-    wxCHECK_MSG( item.IsOk(), FALSE, _T("invalid item in wxGenericTreeCtrl::GetBoundingRect") );
+    wxCHECK_MSG( item.IsOk(), false,
+                 "invalid item in wxGenericTreeCtrl::GetBoundingRect" );
  
      wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
  
  
      wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
  
-    int startX, startY;
-    GetViewStart(& startX, & startY);
+    if ( textOnly )
+    {
+        int image_h = 0, image_w = 0;
+        int image = ((wxGenericTreeItem*) item.m_pItem)->GetCurrentImage();
+        if ( image != NO_IMAGE && m_imageListNormal )
+        {
+            m_imageListNormal->GetSize( image, image_w, image_h );
+            image_w += MARGIN_BETWEEN_IMAGE_AND_TEXT;
+        }
+
+        int state_h = 0, state_w = 0;
+        int state = ((wxGenericTreeItem*) item.m_pItem)->GetState();
+        if ( state != wxTREE_ITEMSTATE_NONE && m_imageListState )
+        {
+            m_imageListState->GetSize( state, state_w, state_h );
+            if ( image_w != 0 )
+                state_w += MARGIN_BETWEEN_STATE_AND_IMAGE;
+            else
+                state_w += MARGIN_BETWEEN_IMAGE_AND_TEXT;
+        }
+
+        rect.x = i->GetX() + state_w + image_w;
+        rect.width = i->GetWidth() - state_w - image_w;
  
  
-    rect.x = i->GetX() - startX*PIXELS_PER_UNIT;
-    rect.y = i->GetY() - startY*PIXELS_PER_UNIT;
-    rect.width = i->GetWidth();
-    //rect.height = i->GetHeight();
+    }
+    else // the entire line
+    {
+        rect.x = 0;
+        rect.width = GetClientSize().x;
+    }
+
+    rect.y = i->GetY();
      rect.height = GetLineHeight(i);
  
      rect.height = GetLineHeight(i);
  
-    return TRUE;
-}
+    // we have to return the logical coordinates, not physical ones
+    rect.SetTopLeft(CalcScrolledPosition(rect.GetTopLeft()));
  
  
-/* **** */
+    return true;
+}
  
  
-void wxGenericTreeCtrl::Edit( const wxTreeItemId& item )
+wxTextCtrl *wxGenericTreeCtrl::EditLabel(const wxTreeItemId& item,
+                                  wxClassInfo * WXUNUSED(textCtrlClass))
  {
  {
-    if (!item.IsOk()) return;
-
-    m_currentEdit = (wxGenericTreeItem*) item.m_pItem;
+    wxCHECK_MSG( item.IsOk(), NULL, wxT("can't edit an invalid item") );
  
  
-    wxTreeEvent te( wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, GetId() );
-    te.m_item = (long) m_currentEdit;
-    te.SetEventObject( this );
-    GetEventHandler()->ProcessEvent( te );
+    wxGenericTreeItem *itemEdit = (wxGenericTreeItem *)item.m_pItem;
  
  
-    if (!te.IsAllowed()) return;
+    wxTreeEvent te(wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, this, itemEdit);
+    if ( GetEventHandler()->ProcessEvent( te ) && !te.IsAllowed() )
+    {
+        // vetoed by user
+        return NULL;
+    }
  
      // We have to call this here because the label in
      // question might just have been added and no screen
      // update taken place.
  
      // We have to call this here because the label in
      // question might just have been added and no screen
      // update taken place.
-    if (m_dirty) wxYieldIfNeeded();
+    if ( m_dirty )
+#if defined( __WXMSW__ ) || defined(__WXMAC__)
+        Update();
+#else
+        DoDirtyProcessing();
+#endif
  
  
-    wxString s = m_currentEdit->GetText();
-    int x = m_currentEdit->GetX();
-    int y = m_currentEdit->GetY();
-    int w = m_currentEdit->GetWidth();
-    int h = m_currentEdit->GetHeight();
+    // TODO: use textCtrlClass here to create the control of correct class
+    m_textCtrl = new wxTreeTextCtrl(this, itemEdit);
  
  
-    int image_h = 0;
-    int image_w = 0;
+    m_textCtrl->SetFocus();
  
  
-    int image = m_currentEdit->GetCurrentImage();
-    if ( image != NO_IMAGE )
-    {
-        if ( m_imageListNormal )
-        {
-            m_imageListNormal->GetSize( image, image_w, image_h );
-            image_w += 4;
-        }
-        else
-        {
-            wxFAIL_MSG(_T("you must create an image list to use images!"));
-        }
-    }
-    x += image_w;
-    w -= image_w + 4; // I don't know why +4 is needed
+    return m_textCtrl;
+}
  
  
-    wxClientDC dc(this);
-    PrepareDC( dc );
-    x = dc.LogicalToDeviceX( x );
-    y = dc.LogicalToDeviceY( y );
+// returns a pointer to the text edit control if the item is being
+// edited, NULL otherwise (it's assumed that no more than one item may
+// be edited simultaneously)
+wxTextCtrl* wxGenericTreeCtrl::GetEditControl() const
+{
+    return m_textCtrl;
+}
+
+void wxGenericTreeCtrl::EndEditLabel(const wxTreeItemId& WXUNUSED(item),
+                                     bool discardChanges)
+{
+    wxCHECK_RET( m_textCtrl, wxT("not editing label") );
  
  
-    wxTreeTextCtrl *text = new wxTreeTextCtrl(this, -1,
-                                              &m_renameAccept,
-                                              &m_renameRes,
-                                              this,
-                                              s,
-                                              wxPoint(x-4,y-4),
-                                              wxSize(w+11,h+8));
-    text->SetFocus();
+    m_textCtrl->EndEdit(discardChanges);
  }
  
  }
  
-void wxGenericTreeCtrl::OnRenameTimer()
+bool wxGenericTreeCtrl::OnRenameAccept(wxGenericTreeItem *item,
+                                       const wxString& value)
  {
  {
-    Edit( m_current );
+    wxTreeEvent le(wxEVT_COMMAND_TREE_END_LABEL_EDIT, this, item);
+    le.m_label = value;
+    le.m_editCancelled = false;
+
+    return !GetEventHandler()->ProcessEvent( le ) || le.IsAllowed();
  }
  
  }
  
-void wxGenericTreeCtrl::OnRenameAccept()
+void wxGenericTreeCtrl::OnRenameCancelled(wxGenericTreeItem *item)
  {
  {
-    // TODO if the validator fails this causes a crash
-    wxTreeEvent le( wxEVT_COMMAND_TREE_END_LABEL_EDIT, GetId() );
-    le.m_item = (long) m_currentEdit;
-    le.SetEventObject( this );
-    le.m_label = m_renameRes;
-    GetEventHandler()->ProcessEvent( le );
+    // let owner know that the edit was cancelled
+    wxTreeEvent le(wxEVT_COMMAND_TREE_END_LABEL_EDIT, this, item);
+    le.m_label = wxEmptyString;
+    le.m_editCancelled = true;
  
  
-    if (!le.IsAllowed()) return;
+    GetEventHandler()->ProcessEvent( le );
+}
  
  
-    SetItemText( m_currentEdit, m_renameRes );
+void wxGenericTreeCtrl::OnRenameTimer()
+{
+    EditLabel( m_current );
  }
  
  void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
  {
  }
  
  void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
  {
-    if ( !m_anchor ) return;
+    if ( !m_anchor )return;
+
+    wxPoint pt = CalcUnscrolledPosition(event.GetPosition());
+
+    // Is the mouse over a tree item button?
+    int flags = 0;
+    wxGenericTreeItem *thisItem = m_anchor->HitTest(pt, this, flags, 0);
+    wxGenericTreeItem *underMouse = thisItem;
+#if wxUSE_TOOLTIPS
+    bool underMouseChanged = (underMouse != m_underMouse) ;
+#endif // wxUSE_TOOLTIPS
+
+    if ((underMouse) &&
+        (flags & wxTREE_HITTEST_ONITEMBUTTON) &&
+        (!event.LeftIsDown()) &&
+        (!m_isDragging) &&
+        (!m_renameTimer || !m_renameTimer->IsRunning()))
+    {
+    }
+    else
+    {
+        underMouse = NULL;
+    }
+
+    if (underMouse != m_underMouse)
+    {
+         if (m_underMouse)
+         {
+            // unhighlight old item
+            wxGenericTreeItem *tmp = m_underMouse;
+            m_underMouse = NULL;
+            RefreshLine( tmp );
+         }
+
+         m_underMouse = underMouse;
+         if (m_underMouse)
+            RefreshLine( m_underMouse );
+    }
+
+#if wxUSE_TOOLTIPS
+    // Determines what item we are hovering over and need a tooltip for
+    wxTreeItemId hoverItem = thisItem;
+
+    // We do not want a tooltip if we are dragging, or if the rename timer is
+    // running
+    if ( underMouseChanged &&
+            hoverItem.IsOk() &&
+              !m_isDragging &&
+                (!m_renameTimer || !m_renameTimer->IsRunning()) )
+    {
+        // Ask the tree control what tooltip (if any) should be shown
+        wxTreeEvent
+            hevent(wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP,  this, hoverItem);
+
+        if ( GetEventHandler()->ProcessEvent(hevent) && hevent.IsAllowed() )
+        {
+            SetToolTip(hevent.m_label);
+        }
+    }
+#endif
  
  
-    // we process left mouse up event (enables in-place edit), right down
+    // we process left mouse up event (enables in-place edit), middle/right down
      // (pass to the user code), left dbl click (activate item) and
      // dragging/moving events for items drag-and-drop
      if ( !(event.LeftDown() ||
             event.LeftUp() ||
      // (pass to the user code), left dbl click (activate item) and
      // dragging/moving events for items drag-and-drop
      if ( !(event.LeftDown() ||
             event.LeftUp() ||
+           event.MiddleDown() ||
             event.RightDown() ||
             event.LeftDClick() ||
             event.Dragging() ||
             event.RightDown() ||
             event.LeftDClick() ||
             event.Dragging() ||
@@ -2678,21 +3557,14 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
          return;
      }
  
          return;
      }
  
-    wxClientDC dc(this);
-    PrepareDC(dc);
-    wxCoord x = dc.DeviceToLogicalX( event.GetX() );
-    wxCoord y = dc.DeviceToLogicalY( event.GetY() );
  
  
-    int flags = 0;
-    wxGenericTreeItem *item = m_anchor->HitTest( wxPoint(x,y),
-                                                 this,
-                                                 flags,
-                                                 0 );
+    flags = 0;
+    wxGenericTreeItem *item = m_anchor->HitTest(pt, this, flags, 0);
  
      if ( event.Dragging() && !m_isDragging )
      {
          if (m_dragCount == 0)
  
      if ( event.Dragging() && !m_isDragging )
      {
          if (m_dragCount == 0)
-            m_dragStart = wxPoint(x,y);
+            m_dragStart = pt;
  
          m_dragCount++;
  
  
          m_dragCount++;
  
@@ -2706,9 +3578,8 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
                                ? wxEVT_COMMAND_TREE_BEGIN_RDRAG
                                : wxEVT_COMMAND_TREE_BEGIN_DRAG;
  
                                ? wxEVT_COMMAND_TREE_BEGIN_RDRAG
                                : wxEVT_COMMAND_TREE_BEGIN_DRAG;
  
-        wxTreeEvent nevent( command, GetId() );
-        nevent.m_item = (long) m_current;
-        nevent.SetEventObject(this);
+        wxTreeEvent nevent(command,  this, m_current);
+        nevent.SetPoint(CalcScrolledPosition(pt));
  
          // by default the dragging is not supported, the user code must
          // explicitly allow the event for it to take place
  
          // by default the dragging is not supported, the user code must
          // explicitly allow the event for it to take place
@@ -2717,7 +3588,7 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
          if ( GetEventHandler()->ProcessEvent(nevent) && nevent.IsAllowed() )
          {
              // we're going to drag this item
          if ( GetEventHandler()->ProcessEvent(nevent) && nevent.IsAllowed() )
          {
              // we're going to drag this item
-            m_isDragging = TRUE;
+            m_isDragging = true;
  
              // remember the old cursor because we will change it while
              // dragging
  
              // remember the old cursor because we will change it while
              // dragging
@@ -2730,7 +3601,7 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
  
                  if ( m_oldSelection )
                  {
  
                  if ( m_oldSelection )
                  {
-                    m_oldSelection->SetHilight(FALSE);
+                    m_oldSelection->SetHilight(false);
                      RefreshLine(m_oldSelection);
                  }
              }
                      RefreshLine(m_oldSelection);
                  }
              }
@@ -2738,7 +3609,7 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
              CaptureMouse();
          }
      }
              CaptureMouse();
          }
      }
-    else if ( event.Moving() )
+    else if ( event.Dragging() )
      {
          if ( item != m_dropTarget )
          {
      {
          if ( item != m_dropTarget )
          {
@@ -2750,41 +3621,63 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
              // highlight the current drop target if any
              DrawDropEffect(m_dropTarget);
  
              // highlight the current drop target if any
              DrawDropEffect(m_dropTarget);
  
+#if defined(__WXMSW__) || defined(__WXMAC__) || defined(__WXGTK20__)
+            Update();
+#else
+            // TODO: remove this call or use wxEventLoopBase::GetActive()->YieldFor(wxEVT_CATEGORY_UI)
+            //       instead (needs to be tested!)
              wxYieldIfNeeded();
              wxYieldIfNeeded();
+#endif
          }
      }
      else if ( (event.LeftUp() || event.RightUp()) && m_isDragging )
      {
          }
      }
      else if ( (event.LeftUp() || event.RightUp()) && m_isDragging )
      {
+        ReleaseMouse();
+
          // erase the highlighting
          DrawDropEffect(m_dropTarget);
  
          if ( m_oldSelection )
          {
          // erase the highlighting
          DrawDropEffect(m_dropTarget);
  
          if ( m_oldSelection )
          {
-            m_oldSelection->SetHilight(TRUE);
+            m_oldSelection->SetHilight(true);
              RefreshLine(m_oldSelection);
              RefreshLine(m_oldSelection);
-            m_oldSelection = (wxGenericTreeItem *)NULL;
+            m_oldSelection = NULL;
          }
  
          // generate the drag end event
          }
  
          // generate the drag end event
-        wxTreeEvent event(wxEVT_COMMAND_TREE_END_DRAG, GetId());
-
-        event.m_item = (long) item;
-        event.m_pointDrag = wxPoint(x, y);
-        event.SetEventObject(this);
+        wxTreeEvent eventEndDrag(wxEVT_COMMAND_TREE_END_DRAG,  this, item);
  
  
-        (void)GetEventHandler()->ProcessEvent(event);
+        eventEndDrag.m_pointDrag = CalcScrolledPosition(pt);
  
  
-        m_isDragging = FALSE;
-        m_dropTarget = (wxGenericTreeItem *)NULL;
+        (void)GetEventHandler()->ProcessEvent(eventEndDrag);
  
  
-        ReleaseMouse();
+        m_isDragging = false;
+        m_dropTarget = NULL;
  
          SetCursor(m_oldCursor);
  
  
          SetCursor(m_oldCursor);
  
+#if defined( __WXMSW__ ) || defined(__WXMAC__) || defined(__WXGTK20__)
+        Update();
+#else
+        // TODO: remove this call or use wxEventLoopBase::GetActive()->YieldFor(wxEVT_CATEGORY_UI)
+        //       instead (needs to be tested!)
          wxYieldIfNeeded();
          wxYieldIfNeeded();
+#endif
      }
      else
      {
      }
      else
      {
+        // If we got to this point, we are not dragging or moving the mouse.
+        // Because the code in carbon/toplevel.cpp will only set focus to the
+        // tree if we skip for EVT_LEFT_DOWN, we MUST skip this event here for
+        // focus to work.
+        // We skip even if we didn't hit an item because we still should
+        // restore focus to the tree control even if we didn't exactly hit an
+        // item.
+        if ( event.LeftDown() )
+        {
+            event.Skip();
+        }
+
          // here we process only the messages which happen on tree items
  
          m_dragCount = 0;
          // here we process only the messages which happen on tree items
  
          m_dragCount = 0;
@@ -2793,33 +3686,81 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
  
          if ( event.RightDown() )
          {
  
          if ( event.RightDown() )
          {
-            wxTreeEvent nevent(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK, GetId());
-            nevent.m_item = (long) item;
-            CalcScrolledPosition(x, y,
-                                 &nevent.m_pointDrag.x,
-                                 &nevent.m_pointDrag.y);
-            nevent.SetEventObject(this);
-            GetEventHandler()->ProcessEvent(nevent);
+            // If the item is already selected, do not update the selection.
+            // Multi-selections should not be cleared if a selected item is
+            // clicked.
+            if (!IsSelected(item))
+            {
+                DoSelectItem(item, true, false);
+            }
+
+            wxTreeEvent
+                nevent(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK,  this, item);
+            nevent.m_pointDrag = CalcScrolledPosition(pt);
+            event.Skip(!GetEventHandler()->ProcessEvent(nevent));
+
+            // Consistent with MSW (for now), send the ITEM_MENU *after*
+            // the RIGHT_CLICK event. TODO: This behaviour may change.
+            wxTreeEvent nevent2(wxEVT_COMMAND_TREE_ITEM_MENU,  this, item);
+            nevent2.m_pointDrag = CalcScrolledPosition(pt);
+            GetEventHandler()->ProcessEvent(nevent2);
+        }
+        else if ( event.MiddleDown() )
+        {
+            wxTreeEvent
+                nevent(wxEVT_COMMAND_TREE_ITEM_MIDDLE_CLICK,  this, item);
+            nevent.m_pointDrag = CalcScrolledPosition(pt);
+            event.Skip(!GetEventHandler()->ProcessEvent(nevent));
          }
          else if ( event.LeftUp() )
          {
          }
          else if ( event.LeftUp() )
          {
+            if (flags & wxTREE_HITTEST_ONITEMSTATEICON)
+            {
+                wxTreeEvent
+                    nevent(wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK, this, item);
+                GetEventHandler()->ProcessEvent(nevent);
+            }
+
+            // this facilitates multiple-item drag-and-drop
+
+            if ( /* item && */ HasFlag(wxTR_MULTIPLE))
+            {
+                wxArrayTreeItemIds selections;
+                size_t count = GetSelections(selections);
+
+                if (count > 1 &&
+                    !event.CmdDown() &&
+                    !event.ShiftDown())
+                {
+                    DoSelectItem(item, true, false);
+                }
+            }
+
              if ( m_lastOnSame )
              {
                  if ( (item == m_current) &&
                       (flags & wxTREE_HITTEST_ONITEMLABEL) &&
                       HasFlag(wxTR_EDIT_LABELS) )
                  {
              if ( m_lastOnSame )
              {
                  if ( (item == m_current) &&
                       (flags & wxTREE_HITTEST_ONITEMLABEL) &&
                       HasFlag(wxTR_EDIT_LABELS) )
                  {
-                    if ( m_renameTimer->IsRunning() )
-                        m_renameTimer->Stop();
+                    if ( m_renameTimer )
+                    {
+                        if ( m_renameTimer->IsRunning() )
+                            m_renameTimer->Stop();
+                    }
+                    else
+                    {
+                        m_renameTimer = new wxTreeRenameTimer( this );
+                    }
  
  
-                    m_renameTimer->Start( 100, TRUE );
+                    m_renameTimer->Start( wxTreeRenameTimer::DELAY, true );
                  }
  
                  }
  
-                m_lastOnSame = FALSE;
+                m_lastOnSame = false;
              }
          }
              }
          }
-        else // !RightDown() && !LeftUp() ==> LeftDown() || LeftDClick()
+        else // !RightDown() && !MiddleDown() && !LeftUp()
          {
          {
+            // ==> LeftDown() || LeftDClick()
              if ( event.LeftDown() )
              {
                  m_lastOnSame = item == m_current;
              if ( event.LeftDown() )
              {
                  m_lastOnSame = item == m_current;
@@ -2838,30 +3779,41 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
                  return;
              }
  
                  return;
              }
  
-            // how should the selection work for this event?
-            bool is_multiple, extended_select, unselect_others;
-            EventFlagsToSelType(GetWindowStyleFlag(),
-                                event.ShiftDown(),
-                                event.ControlDown(),
-                                is_multiple, extended_select, unselect_others);
  
  
-            SelectItem(item, unselect_others, extended_select);
+            // clear the previously selected items, if the
+            // user clicked outside of the present selection.
+            // otherwise, perform the deselection on mouse-up.
+            // this allows multiple drag and drop to work.
+            // but if Cmd is down, toggle selection of the clicked item
+            if (!IsSelected(item) || event.CmdDown())
+            {
+                // how should the selection work for this event?
+                bool is_multiple, extended_select, unselect_others;
+                EventFlagsToSelType(GetWindowStyleFlag(),
+                                    event.ShiftDown(),
+                                    event.CmdDown(),
+                                    is_multiple,
+                                    extended_select,
+                                    unselect_others);
+
+                DoSelectItem(item, unselect_others, extended_select);
+            }
+
  
              // For some reason, Windows isn't recognizing a left double-click,
              // so we need to simulate it here.  Allow 200 milliseconds for now.
              if ( event.LeftDClick() )
              {
                  // double clicking should not start editing the item label
  
              // For some reason, Windows isn't recognizing a left double-click,
              // so we need to simulate it here.  Allow 200 milliseconds for now.
              if ( event.LeftDClick() )
              {
                  // double clicking should not start editing the item label
-                m_renameTimer->Stop();
-                m_lastOnSame = FALSE;
+                if ( m_renameTimer )
+                    m_renameTimer->Stop();
+
+                m_lastOnSame = false;
  
                  // send activate event first
  
                  // send activate event first
-                wxTreeEvent nevent( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
-                nevent.m_item = (long) item;
-                CalcScrolledPosition(x, y,
-                                     &nevent.m_pointDrag.x,
-                                     &nevent.m_pointDrag.y);
-                nevent.SetEventObject( this );
+                wxTreeEvent
+                    nevent(wxEVT_COMMAND_TREE_ITEM_ACTIVATED,  this, item);
+                nevent.m_pointDrag = CalcScrolledPosition(pt);
                  if ( !GetEventHandler()->ProcessEvent( nevent ) )
                  {
                      // if the user code didn't process the activate event,
                  if ( !GetEventHandler()->ProcessEvent( nevent ) )
                  {
                      // if the user code didn't process the activate event,
@@ -2877,64 +3829,33 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
      }
  }
  
      }
  }
  
-void wxGenericTreeCtrl::OnIdle( wxIdleEvent &WXUNUSED(event) )
-{
-    /* after all changes have been done to the tree control,
-     * we actually redraw the tree when everything is over */
-
-    if (!m_dirty) return;
-
-    m_dirty = FALSE;
-
-    CalculatePositions();
-    Refresh();
-    AdjustMyScrollbars();
-}
-
-void wxGenericTreeCtrl::CalculateSize( wxGenericTreeItem *item, wxDC &dc )
+void wxGenericTreeCtrl::OnInternalIdle()
  {
  {
-    wxCoord text_w = 0;
-    wxCoord text_h = 0;
+    wxWindow::OnInternalIdle();
  
  
-    if (item->IsBold())
-        dc.SetFont(m_boldFont);
-
-    dc.GetTextExtent( item->GetText(), &text_w, &text_h );
-    text_h+=2;
-
-    // restore normal font
-    dc.SetFont( m_normalFont );
-
-    int image_h = 0;
-    int image_w = 0;
-    int image = item->GetCurrentImage();
-    if ( image != NO_IMAGE )
+    // Check if we need to select the root item
+    // because nothing else has been selected.
+    // Delaying it means that we can invoke event handlers
+    // as required, when a first item is selected.
+    if (!HasFlag(wxTR_MULTIPLE) && !GetSelection().IsOk())
      {
      {
-        if ( m_imageListNormal )
-        {
-            m_imageListNormal->GetSize( image, image_w, image_h );
-            image_w += 4;
-        }
+        if (m_select_me)
+            SelectItem(m_select_me);
+        else if (GetRootItem().IsOk())
+            SelectItem(GetRootItem());
      }
  
      }
  
-    int total_h = (image_h > text_h) ? image_h : text_h;
-
-    if (total_h < 30)
-        total_h += 2;            // at least 2 pixels
-    else
-        total_h += total_h/10;   // otherwise 10% extra spacing
-
-    item->SetHeight(total_h);
-    if (total_h>m_lineHeight)
-        m_lineHeight=total_h;
-
-    item->SetWidth(image_w+text_w+2);
+    // after all changes have been done to the tree control,
+    // actually redraw the tree when everything is over
+    if (m_dirty)
+        DoDirtyProcessing();
  }
  
  }
  
-// -----------------------------------------------------------------------------
-// for developper : y is now the top of the level
-// not the middle of it !
-void wxGenericTreeCtrl::CalculateLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y )
+void
+wxGenericTreeCtrl::CalculateLevel(wxGenericTreeItem *item,
+                                  wxDC &dc,
+                                  int level,
+                                  int &y )
  {
      int x = level*m_indent;
      if (!HasFlag(wxTR_HIDE_ROOT))
  {
      int x = level*m_indent;
      if (!HasFlag(wxTR_HIDE_ROOT))
@@ -2948,7 +3869,7 @@ void wxGenericTreeCtrl::CalculateLevel( wxGenericTreeItem *item, wxDC &dc, int l
          goto Recurse;
      }
  
          goto Recurse;
      }
  
-    CalculateSize( item, dc );
+    item->CalculateSize(this, dc);
  
      // set its position
      item->SetX( x+m_spacing );
  
      // set its position
      item->SetX( x+m_spacing );
@@ -2963,7 +3884,7 @@ void wxGenericTreeCtrl::CalculateLevel( wxGenericTreeItem *item, wxDC &dc, int l
  
    Recurse:
      wxArrayGenericTreeItems& children = item->GetChildren();
  
    Recurse:
      wxArrayGenericTreeItems& children = item->GetChildren();
-    size_t n, count = children.Count();
+    size_t n, count = children.GetCount();
      ++level;
      for (n = 0; n < count; ++n )
          CalculateLevel( children[n], dc, level, y );  // recurse
      ++level;
      for (n = 0; n < count; ++n )
          CalculateLevel( children[n], dc, level, y );  // recurse
@@ -2986,50 +3907,47 @@ void wxGenericTreeCtrl::CalculatePositions()
      CalculateLevel( m_anchor, dc, 0, y ); // start recursion
  }
  
      CalculateLevel( m_anchor, dc, 0, y ); // start recursion
  }
  
-void wxGenericTreeCtrl::RefreshSubtree(wxGenericTreeItem *item)
+void wxGenericTreeCtrl::Refresh(bool eraseBackground, const wxRect *rect)
  {
  {
-    if (m_dirty) return;
+    if ( !IsFrozen() )
+        wxTreeCtrlBase::Refresh(eraseBackground, rect);
+}
  
  
-    wxClientDC dc(this);
-    PrepareDC(dc);
+void wxGenericTreeCtrl::RefreshSubtree(wxGenericTreeItem *item)
+{
+    if (m_dirty || IsFrozen() )
+        return;
  
  
-    int cw = 0;
-    int ch = 0;
-    GetClientSize( &cw, &ch );
+    wxSize client = GetClientSize();
  
      wxRect rect;
  
      wxRect rect;
-    rect.x = dc.LogicalToDeviceX( 0 );
-    rect.width = cw;
-    rect.y = dc.LogicalToDeviceY( item->GetY() );
-    rect.height = ch;
+    CalcScrolledPosition(0, item->GetY(), NULL, &rect.y);
+    rect.width = client.x;
+    rect.height = client.y;
  
  
-    Refresh( TRUE, &rect );
+    Refresh(true, &rect);
  
      AdjustMyScrollbars();
  }
  
  void wxGenericTreeCtrl::RefreshLine( wxGenericTreeItem *item )
  {
  
      AdjustMyScrollbars();
  }
  
  void wxGenericTreeCtrl::RefreshLine( wxGenericTreeItem *item )
  {
-    if (m_dirty) return;
-
-    wxClientDC dc(this);
-    PrepareDC( dc );
-
-    int cw = 0;
-    int ch = 0;
-    GetClientSize( &cw, &ch );
+    if (m_dirty || IsFrozen() )
+        return;
  
      wxRect rect;
  
      wxRect rect;
-    rect.x = dc.LogicalToDeviceX( 0 );
-    rect.y = dc.LogicalToDeviceY( item->GetY() );
-    rect.width = cw;
+    CalcScrolledPosition(0, item->GetY(), NULL, &rect.y);
+    rect.width = GetClientSize().x;
      rect.height = GetLineHeight(item); //dc.GetCharHeight() + 6;
  
      rect.height = GetLineHeight(item); //dc.GetCharHeight() + 6;
  
-    Refresh( TRUE, &rect );
+    Refresh(true, &rect);
  }
  
  void wxGenericTreeCtrl::RefreshSelected()
  {
  }
  
  void wxGenericTreeCtrl::RefreshSelected()
  {
+    if (IsFrozen())
+        return;
+
      // TODO: this is awfully inefficient, we should keep the list of all
      //       selected items internally, should be much faster
      if ( m_anchor )
      // TODO: this is awfully inefficient, we should keep the list of all
      //       selected items internally, should be much faster
      if ( m_anchor )
@@ -3038,6 +3956,9 @@ void wxGenericTreeCtrl::RefreshSelected()
  
  void wxGenericTreeCtrl::RefreshSelectedUnder(wxGenericTreeItem *item)
  {
  
  void wxGenericTreeCtrl::RefreshSelectedUnder(wxGenericTreeItem *item)
  {
+    if (IsFrozen())
+        return;
+
      if ( item->IsSelected() )
          RefreshLine(item);
  
      if ( item->IsSelected() )
          RefreshLine(item);
  
@@ -3049,6 +3970,16 @@ void wxGenericTreeCtrl::RefreshSelectedUnder(wxGenericTreeItem *item)
      }
  }
  
      }
  }
  
+void wxGenericTreeCtrl::DoThaw()
+{
+    wxTreeCtrlBase::DoThaw();
+
+    if ( m_dirty )
+        DoDirtyProcessing();
+    else
+        Refresh();
+}
+
  // ----------------------------------------------------------------------------
  // changing colours: we need to refresh the tree control
  // ----------------------------------------------------------------------------
  // ----------------------------------------------------------------------------
  // changing colours: we need to refresh the tree control
  // ----------------------------------------------------------------------------
@@ -3056,21 +3987,96 @@ void wxGenericTreeCtrl::RefreshSelectedUnder(wxGenericTreeItem *item)
  bool wxGenericTreeCtrl::SetBackgroundColour(const wxColour& colour)
  {
      if ( !wxWindow::SetBackgroundColour(colour) )
  bool wxGenericTreeCtrl::SetBackgroundColour(const wxColour& colour)
  {
      if ( !wxWindow::SetBackgroundColour(colour) )
-        return FALSE;
+        return false;
  
      Refresh();
  
  
      Refresh();
  
-    return TRUE;
+    return true;
  }
  
  bool wxGenericTreeCtrl::SetForegroundColour(const wxColour& colour)
  {
      if ( !wxWindow::SetForegroundColour(colour) )
  }
  
  bool wxGenericTreeCtrl::SetForegroundColour(const wxColour& colour)
  {
      if ( !wxWindow::SetForegroundColour(colour) )
-        return FALSE;
+        return false;
+
+    Refresh();
+
+    return true;
+}
+
+// Process the tooltip event, to speed up event processing.
+// Doesn't actually get a tooltip.
+void wxGenericTreeCtrl::OnGetToolTip( wxTreeEvent &event )
+{
+    event.Veto();
+}
+
+
+// NOTE: If using the wxListBox visual attributes works everywhere then this can
+// be removed, as well as the #else case below.
+#define _USE_VISATTR 0
+
+//static
+wxVisualAttributes
+#if _USE_VISATTR
+wxGenericTreeCtrl::GetClassDefaultAttributes(wxWindowVariant variant)
+#else
+wxGenericTreeCtrl::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
+#endif
+{
+#if _USE_VISATTR
+    // Use the same color scheme as wxListBox
+    return wxListBox::GetClassDefaultAttributes(variant);
+#else
+    wxVisualAttributes attr;
+    attr.colFg = wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOXTEXT);
+    attr.colBg = wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOX);
+    attr.font  = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
+    return attr;
+#endif
+}
+
+void wxGenericTreeCtrl::DoDirtyProcessing()
+{
+    if (IsFrozen())
+        return;
+
+    m_dirty = false;
  
  
+    CalculatePositions();
      Refresh();
      Refresh();
+    AdjustMyScrollbars();
+}
+
+wxSize wxGenericTreeCtrl::DoGetBestSize() const
+{
+    // make sure all positions are calculated as normally this only done during
+    // idle time but we need them for base class DoGetBestSize() to return the
+    // correct result
+    wxConstCast(this, wxGenericTreeCtrl)->CalculatePositions();
+
+    wxSize size = wxTreeCtrlBase::DoGetBestSize();
+
+    // there seems to be an implicit extra border around the items, although
+    // I'm not really sure where does it come from -- but without this, the
+    // scrollbars appear in a tree with default/best size
+    size.IncBy(4, 4);
+
+    // and the border has to be rounded up to a multiple of PIXELS_PER_UNIT or
+    // scrollbars still appear
+    const wxSize& borderSize = GetWindowBorderSize();
+
+    int dx = (size.x - borderSize.x) % PIXELS_PER_UNIT;
+    if ( dx )
+        size.x += PIXELS_PER_UNIT - dx;
+    int dy = (size.y - borderSize.y) % PIXELS_PER_UNIT;
+    if ( dy )
+        size.y += PIXELS_PER_UNIT - dy;
+
+    // we need to update the cache too as the base class cached its own value
+    CacheBestSize(size);
  
  
-    return TRUE;
+    return size;
  }
  
  #endif // wxUSE_TREECTRL
  }
  
  #endif // wxUSE_TREECTRL