]> git.saurik.com Git - wxWidgets.git/blobdiff - src/generic/treectlg.cpp
cleaned up the checkbox creation code (~70 lines of code became 3)
[wxWidgets.git] / src / generic / treectlg.cpp
index c65b85bf946f3f383a69966488fb1c5e6e1187cd..ce148cd3012e029e15cb4d491a1a3697faa89450 100644 (file)
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
-#pragma hdrstop
+    #pragma hdrstop
 #endif
 
+#if wxUSE_TREECTRL
+
+#include "wx/treebase.h"
 #include "wx/generic/treectlg.h"
+#include "wx/timer.h"
+#include "wx/textctrl.h"
 #include "wx/imaglist.h"
 #include "wx/settings.h"
-#include "wx/log.h"
-#include "wx/intl.h"
-#include "wx/dynarray.h"
-#include "wx/arrimpl.cpp"
 #include "wx/dcclient.h"
-#include "wx/msgdlg.h"
 
 // -----------------------------------------------------------------------------
 // array types
@@ -44,7 +44,7 @@
 
 class WXDLLEXPORT wxGenericTreeItem;
 
-WX_DEFINE_ARRAY(wxGenericTreeItem *, wxArrayGenericTreeItems);
+WX_DEFINE_EXPORTED_ARRAY(wxGenericTreeItem *, wxArrayGenericTreeItems);
 //WX_DEFINE_OBJARRAY(wxArrayTreeItemIds);
 
 // ----------------------------------------------------------------------------
@@ -55,6 +55,54 @@ static const int NO_IMAGE = -1;
 
 #define PIXELS_PER_UNIT 10
 
+// ----------------------------------------------------------------------------
+// Aqua arrows
+// ----------------------------------------------------------------------------
+
+/* 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        "
+};
+
+/* 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      "
+};
+
 // -----------------------------------------------------------------------------
 // private classes
 // -----------------------------------------------------------------------------
@@ -75,7 +123,6 @@ private:
 class WXDLLEXPORT wxTreeTextCtrl: public wxTextCtrl
 {
 public:
-    wxTreeTextCtrl() { }
     wxTreeTextCtrl( wxWindow *parent,
                     const wxWindowID id,
                     bool *accept,
@@ -89,16 +136,17 @@ public:
                     const wxString &name = wxTextCtrlNameStr );
 
     void OnChar( wxKeyEvent &event );
+    void OnKeyUp( wxKeyEvent &event );
     void OnKillFocus( wxFocusEvent &event );
 
 private:
     bool               *m_accept;
     wxString           *m_res;
-    wxGenericTreeCtrl         *m_owner;
+    wxGenericTreeCtrl  *m_owner;
     wxString            m_startValue;
+    bool                m_finished;
 
     DECLARE_EVENT_TABLE()
-    DECLARE_DYNAMIC_CLASS(wxTreeTextCtrl);
 };
 
 // a tree item
@@ -108,10 +156,10 @@ public:
     // ctors & dtor
     wxGenericTreeItem() { m_data = NULL; }
     wxGenericTreeItem( wxGenericTreeItem *parent,
-            const wxString& text,
-            wxDC& dc,
-            int image, int selImage,
-            wxTreeItemData *data );
+                       const wxString& text,
+                       int image,
+                       int selImage,
+                       wxTreeItemData *data );
 
     ~wxGenericTreeItem();
 
@@ -147,15 +195,12 @@ public:
     void SetHeight(int h) { m_height = h; }
     void SetWidth(int w) { m_width = w; }
 
-
     wxGenericTreeItem *GetParent() const { return m_parent; }
 
     // operations
         // deletes all children notifying the treectrl about it if !NULL
         // pointer given
     void DeleteChildren(wxGenericTreeCtrl *tree = NULL);
-        // FIXME don't know what is it for
-    void Reset();
 
     // get count of all children (and grand children if 'recursively')
     size_t GetChildrenCount(bool recursively = TRUE) const;
@@ -163,13 +208,15 @@ public:
     void Insert(wxGenericTreeItem *child, size_t index)
     { m_children.Insert(child, index); }
 
-    void SetCross( int x, int y );
     void GetSize( int &x, int &y, const wxGenericTreeCtrl* );
 
         // 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
-    wxGenericTreeItem *HitTest( const wxPoint& point, const wxGenericTreeCtrl *, int &flags);
+    wxGenericTreeItem *HitTest( const wxPoint& point,
+                                const wxGenericTreeCtrl *,
+                                int &flags,
+                                int level );
 
     void Expand() { m_isCollapsed = FALSE; }
     void Collapse() { m_isCollapsed = TRUE; }
@@ -178,10 +225,10 @@ public:
 
     // status inquiries
     bool HasChildren() const { return !m_children.IsEmpty(); }
-    bool IsSelected()  const { return m_hasHilight; }
+    bool IsSelected()  const { return m_hasHilight != 0; }
     bool IsExpanded()  const { return !m_isCollapsed; }
     bool HasPlus()     const { return m_hasPlus || HasChildren(); }
-    bool IsBold()      const { return m_isBold; }
+    bool IsBold()      const { return m_isBold != 0; }
 
     // attributes
         // get them - may be NULL
@@ -190,19 +237,47 @@ public:
     wxTreeItemAttr& Attr()
     {
         if ( !m_attr )
+        {
             m_attr = new wxTreeItemAttr;
-
+            m_ownsAttr = TRUE;
+        }
         return *m_attr;
     }
+        // set them
+    void SetAttributes(wxTreeItemAttr *attr)
+    {
+        if ( m_ownsAttr ) delete m_attr;
+        m_attr = attr;
+        m_ownsAttr = FALSE;
+    }
+        // set them and delete when done
+    void AssignAttributes(wxTreeItemAttr *attr)
+    {
+        SetAttributes(attr);
+        m_ownsAttr = TRUE;
+    }
 
 private:
-    wxString            m_text;
+    // 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
+
+    wxTreeItemData     *m_data;         // user-provided data
+
+    wxArrayGenericTreeItems m_children; // list of children
+    wxGenericTreeItem  *m_parent;       // parent of this item
+
+    wxTreeItemAttr     *m_attr;         // attributes???
 
     // tree ctrl images for the normal, selected, expanded and
     // expanded+selected states
-    int                 m_images[wxTreeItemIcon_Max];
+    short               m_images[wxTreeItemIcon_Max];
 
-    wxTreeItemData     *m_data;
+    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
 
     // use bitfields to save size
     int                 m_isCollapsed :1;
@@ -210,16 +285,7 @@ private:
     int                 m_hasPlus     :1; // used for item which doesn't have
                                           // children but has a [+] button
     int                 m_isBold      :1; // render the label in bold font
-
-    wxCoord             m_x, m_y;
-    wxCoord             m_height, m_width;
-    int                 m_xCross, m_yCross;
-    int                 m_level;
-
-    wxArrayGenericTreeItems m_children;
-    wxGenericTreeItem  *m_parent;
-
-    wxTreeItemAttr     *m_attr;
+    int                 m_ownsAttr    :1; // delete attribute when done
 };
 
 // =============================================================================
@@ -262,10 +328,9 @@ void wxTreeRenameTimer::Notify()
 // wxTreeTextCtrl (internal)
 //-----------------------------------------------------------------------------
 
-IMPLEMENT_DYNAMIC_CLASS(wxTreeTextCtrl,wxTextCtrl);
-
 BEGIN_EVENT_TABLE(wxTreeTextCtrl,wxTextCtrl)
     EVT_CHAR           (wxTreeTextCtrl::OnChar)
+    EVT_KEY_UP         (wxTreeTextCtrl::OnKeyUp)
     EVT_KILL_FOCUS     (wxTreeTextCtrl::OnKillFocus)
 END_EVENT_TABLE()
 
@@ -280,7 +345,7 @@ wxTreeTextCtrl::wxTreeTextCtrl( wxWindow *parent,
                                 int style,
                                 const wxValidator& validator,
                                 const wxString &name )
-              : wxTextCtrl( parent, id, value, pos, size, style, validator, name )
+    : wxTextCtrl( parent, id, value, pos, size, style, validator, name )
 {
     m_res = res;
     m_accept = accept;
@@ -288,6 +353,7 @@ wxTreeTextCtrl::wxTreeTextCtrl( wxWindow *parent,
     (*m_accept) = FALSE;
     (*m_res) = wxEmptyString;
     m_startValue = value;
+    m_finished = FALSE;
 }
 
 void wxTreeTextCtrl::OnChar( wxKeyEvent &event )
@@ -296,51 +362,72 @@ void wxTreeTextCtrl::OnChar( wxKeyEvent &event )
     {
         (*m_accept) = TRUE;
         (*m_res) = GetValue();
-        
+
+        if ((*m_res) != m_startValue)
+            m_owner->OnRenameAccept();
+
         if (!wxPendingDelete.Member(this))
             wxPendingDelete.Append(this);
 
-        if ((*m_accept) && ((*m_res) != m_startValue))
-            m_owner->OnRenameAccept();
-            
+        m_finished = TRUE;
+        m_owner->SetFocus(); // This doesn't work. TODO.
+
         return;
     }
     if (event.m_keyCode == WXK_ESCAPE)
     {
         (*m_accept) = FALSE;
         (*m_res) = "";
-        
+
         if (!wxPendingDelete.Member(this))
             wxPendingDelete.Append(this);
-            
+
+        m_finished = TRUE;
+        m_owner->SetFocus(); // This doesn't work. TODO.
+
         return;
     }
     event.Skip();
 }
 
-void wxTreeTextCtrl::OnKillFocus( wxFocusEvent &WXUNUSED(event) )
+void wxTreeTextCtrl::OnKeyUp( wxKeyEvent &event )
 {
-    if (!wxPendingDelete.Member(this))
-        wxPendingDelete.Append(this);
+    if (m_finished)
+    {
+        event.Skip();
+        return;
+    }
 
-    if ((*m_accept) && ((*m_res) != m_startValue))
-        m_owner->OnRenameAccept();
+    // 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();
 }
 
-#if 0
-// -----------------------------------------------------------------------------
-// wxTreeEvent
-// -----------------------------------------------------------------------------
+void wxTreeTextCtrl::OnKillFocus( wxFocusEvent &event )
+{
+    if (m_finished)
+    {
+        event.Skip();
+        return;
+    }
 
-IMPLEMENT_DYNAMIC_CLASS(wxTreeEvent, wxNotifyEvent)
+    if (!wxPendingDelete.Member(this))
+        wxPendingDelete.Append(this);
 
-wxTreeEvent::wxTreeEvent( wxEventType commandType, int id )
-           : wxNotifyEvent( commandType, id )
-{
-    m_code = 0;
-    m_itemOld = (wxGenericTreeItem *)NULL;
+    (*m_accept) = TRUE;
+    (*m_res) = GetValue();
+
+    if ((*m_res) != m_startValue)
+        m_owner->OnRenameAccept();
 }
-#endif
 
 // -----------------------------------------------------------------------------
 // wxGenericTreeItem
@@ -348,7 +435,6 @@ wxTreeEvent::wxTreeEvent( wxEventType commandType, int id )
 
 wxGenericTreeItem::wxGenericTreeItem(wxGenericTreeItem *parent,
                                      const wxString& text,
-                                     wxDC& WXUNUSED(dc),
                                      int image, int selImage,
                                      wxTreeItemData *data)
                  : m_text(text)
@@ -360,9 +446,6 @@ wxGenericTreeItem::wxGenericTreeItem(wxGenericTreeItem *parent,
 
     m_data = data;
     m_x = m_y = 0;
-    m_xCross = m_yCross = 0;
-
-    m_level = 0;
 
     m_isCollapsed = TRUE;
     m_hasHilight = FALSE;
@@ -372,6 +455,7 @@ wxGenericTreeItem::wxGenericTreeItem(wxGenericTreeItem *parent,
     m_parent = parent;
 
     m_attr = (wxTreeItemAttr *)NULL;
+    m_ownsAttr = FALSE;
 
     // We don't know the height here yet.
     m_width = 0;
@@ -382,7 +466,7 @@ wxGenericTreeItem::~wxGenericTreeItem()
 {
     delete m_data;
 
-    delete m_attr;
+    if (m_ownsAttr) delete m_attr;
 
     wxASSERT_MSG( m_children.IsEmpty(),
                   wxT("please call DeleteChildren() before deleting the item") );
@@ -409,28 +493,6 @@ void wxGenericTreeItem::SetText( const wxString &text )
     m_text = text;
 }
 
-void wxGenericTreeItem::Reset()
-{
-    m_text.Empty();
-    for ( int i = 0; i < wxTreeItemIcon_Max; i++ )
-    {
-        m_images[i] = NO_IMAGE;
-    }
-
-    m_data = NULL;
-    m_x = m_y =
-    m_height = m_width = 0;
-    m_xCross =
-    m_yCross = 0;
-
-    m_level = 0;
-
-    DeleteChildren();
-    m_isCollapsed = TRUE;
-
-    m_parent = (wxGenericTreeItem *)NULL;
-}
-
 size_t wxGenericTreeItem::GetChildrenCount(bool recursively) const
 {
     size_t count = m_children.Count();
@@ -446,15 +508,10 @@ size_t wxGenericTreeItem::GetChildrenCount(bool recursively) const
     return total;
 }
 
-void wxGenericTreeItem::SetCross( int x, int y )
+void wxGenericTreeItem::GetSize( int &x, int &y,
+                                 const wxGenericTreeCtrl *theButton )
 {
-    m_xCross = x;
-    m_yCross = y;
-}
-
-void wxGenericTreeItem::GetSize( int &x, int &y, const wxGenericTreeCtrl *theTree )
-{
-    int bottomY=m_y+theTree->GetLineHeight(this);
+    int bottomY=m_y+theButton->GetLineHeight(this);
     if ( y < bottomY ) y = bottomY;
     int width = m_x +  m_width;
     if ( x < width ) x = width;
@@ -464,71 +521,81 @@ void wxGenericTreeItem::GetSize( int &x, int &y, const wxGenericTreeCtrl *theTre
         size_t count = m_children.Count();
         for ( size_t n = 0; n < count; ++n )
         {
-            m_children[n]->GetSize( x, y, theTree );
+            m_children[n]->GetSize( x, y, theButton );
         }
     }
 }
 
-wxGenericTreeItem *wxGenericTreeItem::HitTest( const wxPoint& point,
-                                               const wxGenericTreeCtrl *theTree,
-                                               int &flags)
+wxGenericTreeItem *wxGenericTreeItem::HitTest(const wxPoint& point,
+                                              const wxGenericTreeCtrl *theCtrl,
+                                              int &flags,
+                                              int level)
 {
-    if ((point.y > m_y) && (point.y < m_y + theTree->GetLineHeight(this)))
+    // for a hidden root node, don't evaluate it, but do evaluate children
+    if ( !(level == 0 && theCtrl->HasFlag(wxTR_HIDE_ROOT)) )
     {
-        if (point.y < m_y+theTree->GetLineHeight(this)/2 )
-            flags |= wxTREE_HITTEST_ONITEMUPPERPART;
-        else
-            flags |= wxTREE_HITTEST_ONITEMLOWERPART;
-
-        // 5 is the size of the plus sign
-        if ((point.x > m_xCross-5) && (point.x < m_xCross+5) &&
-            (point.y > m_yCross-5) && (point.y < m_yCross+5) &&
-            (IsExpanded() || HasPlus()))
+        // evaluate the item
+        int h = theCtrl->GetLineHeight(this);
+        if ((point.y > m_y) && (point.y < m_y + h))
         {
-            flags|=wxTREE_HITTEST_ONITEMBUTTON;
-            return this;
-        }
+            int y_mid = m_y + h/2;
+            if (point.y < y_mid )
+                flags |= wxTREE_HITTEST_ONITEMUPPERPART;
+            else
+                flags |= wxTREE_HITTEST_ONITEMLOWERPART;
 
-        if ((point.x >= m_x) && (point.x <= m_x+m_width))
-        {
-            int image_w = -1;
-            int image_h;
+            // 5 is the size of the plus sign
+            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) &&
+                HasPlus() && theCtrl->HasButtons() )
+            {
+                flags |= wxTREE_HITTEST_ONITEMBUTTON;
+                return this;
+            }
 
-            // assuming every image (normal and selected ) has the same size !
-            if ( (GetImage() != NO_IMAGE) && theTree->m_imageListNormal )
-                theTree->m_imageListNormal->GetSize(GetImage(), image_w, image_h);
+            if ((point.x >= m_x) && (point.x <= m_x+m_width))
+            {
+                int image_w = -1;
+                int image_h;
 
-            if ((image_w != -1) && (point.x <= m_x + image_w + 1))
-                flags |= wxTREE_HITTEST_ONITEMICON;
-            else
-                flags |= wxTREE_HITTEST_ONITEMLABEL;
+                // 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);
+
+                if ((image_w != -1) && (point.x <= m_x + image_w + 1))
+                    flags |= wxTREE_HITTEST_ONITEMICON;
+                else
+                    flags |= wxTREE_HITTEST_ONITEMLABEL;
+
+                return this;
+            }
+
+            if (point.x < m_x)
+                flags |= wxTREE_HITTEST_ONITEMINDENT;
+            if (point.x > m_x+m_width)
+                flags |= wxTREE_HITTEST_ONITEMRIGHT;
 
             return this;
         }
 
-        if (point.x < m_x)
-            flags |= wxTREE_HITTEST_ONITEMINDENT;
-        if (point.x > m_x+m_width)
-            flags |= wxTREE_HITTEST_ONITEMRIGHT;
-
-        return this;
+        // if children are expanded, fall through to evaluate them
+        if (m_isCollapsed) return (wxGenericTreeItem*) NULL;
     }
-    else
+
+    // evaluate children
+    size_t count = m_children.Count();
+    for ( size_t n = 0; n < count; n++ )
     {
-        if (!m_isCollapsed)
-        {
-            size_t count = m_children.Count();
-            for ( size_t n = 0; n < count; n++ )
-            {
-                wxGenericTreeItem *res = m_children[n]->HitTest( point, theTree, flags );
-                if ( res != NULL )
-                    return res;
-            }
-        }
+        wxGenericTreeItem *res = m_children[n]->HitTest( point,
+                                                         theCtrl,
+                                                         flags,
+                                                         level + 1 );
+        if ( res != NULL )
+            return res;
     }
 
-    flags|=wxTREE_HITTEST_NOWHERE;
-
     return (wxGenericTreeItem*) NULL;
 }
 
@@ -555,12 +622,9 @@ int wxGenericTreeItem::GetCurrentImage() const
             image = GetImage(wxTreeItemIcon_Selected);
     }
 
-    // may be it doesn't have the specific image we want, try the default one
-    // instead
-    if ( image == NO_IMAGE )
-    {
-        image = GetImage();
-    }
+    // maybe it doesn't have the specific image we want,
+    // try the default one instead
+    if ( image == NO_IMAGE ) image = GetImage();
 
     return image;
 }
@@ -580,7 +644,7 @@ BEGIN_EVENT_TABLE(wxGenericTreeCtrl,wxScrolledWindow)
     EVT_IDLE           (wxGenericTreeCtrl::OnIdle)
 END_EVENT_TABLE()
 
-#if !defined(__WXMSW__) || defined(__WIN16__)
+#if !defined(__WXMSW__) || defined(__WIN16__) || defined(__WXUNIVERSAL__)
 /*
  * wxTreeCtrl has to be a real class or we have problems with
  * the run-time information.
@@ -595,69 +659,124 @@ IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxGenericTreeCtrl)
 
 void wxGenericTreeCtrl::Init()
 {
-    m_current =
-    m_key_current =
-    m_anchor = (wxGenericTreeItem *) NULL;
+    m_current = m_key_current = m_anchor = (wxGenericTreeItem *) NULL;
     m_hasFocus = FALSE;
     m_dirty = FALSE;
 
-    m_xScroll = 0;
-    m_yScroll = 0;
     m_lineHeight = 10;
     m_indent = 15;
     m_spacing = 18;
 
     m_hilightBrush = new wxBrush
-    (
-      wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHT),
-      wxSOLID
-    );
-
-    m_imageListNormal =
+                         (
+                            wxSystemSettings::GetColour
+                            (
+                                wxSYS_COLOUR_HIGHLIGHT
+                            ),
+                            wxSOLID
+                         );
+
+    m_hilightUnfocusedBrush = new wxBrush
+                              (
+                                 wxSystemSettings::GetColour
+                                 (
+                                     wxSYS_COLOUR_BTNSHADOW
+                                 ),
+                                 wxSOLID
+                              );
+
+    m_imageListNormal = m_imageListButtons =
     m_imageListState = (wxImageList *) NULL;
+    m_ownsImageListNormal = m_ownsImageListButtons =
+    m_ownsImageListState = FALSE;
 
     m_dragCount = 0;
     m_isDragging = FALSE;
-    m_dropTarget =
-    m_oldSelection = (wxGenericTreeItem *)NULL;
+    m_dropTarget = m_oldSelection = (wxGenericTreeItem *)NULL;
 
     m_renameTimer = new wxTreeRenameTimer( this );
     m_lastOnSame = FALSE;
 
-    m_normalFont = wxSystemSettings::GetSystemFont( 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());
-}
+                         m_normalFont.GetFamily(),
+                         m_normalFont.GetStyle(),
+                         wxBOLD,
+                         m_normalFont.GetUnderlined());
+}
+
+bool wxGenericTreeCtrl::Create(wxWindow *parent,
+                               wxWindowID id,
+                               const wxPoint& pos,
+                               const wxSize& size,
+                               long style,
+                               const wxValidator &validator,
+                               const wxString& name )
+{
+#ifdef __WXMAC__
+    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_AQUA_BUTTONS;
+#endif
 
-bool wxGenericTreeCtrl::Create(wxWindow *parent, wxWindowID id,
-                        const wxPoint& pos, const wxSize& size,
-                        long style,
-                        const wxValidator &validator,
-                        const wxString& name )
-{
-    wxScrolledWindow::Create( parent, id, pos, size, style|wxHSCROLL|wxVSCROLL, name );
+    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;
+    }
+
+    wxScrolledWindow::Create( parent, id, pos, size,
+                              style|wxHSCROLL|wxVSCROLL, name );
+
+    // If the tree display has no buttons, but does have
+    // connecting lines, we can use a narrower layout.
+    // It may not be a good idea to force this...
+    if (!HasButtons() && !HasFlag(wxTR_NO_LINES))
+    {
+        m_indent= 10;
+        m_spacing = 10;
+    }
 
 #if wxUSE_VALIDATORS
     SetValidator( validator );
 #endif
 
-    SetBackgroundColour( wxSystemSettings::GetSystemColour( wxSYS_COLOUR_LISTBOX ) );
+    SetForegroundColour( wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT) );
+    SetBackgroundColour( wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOX) );
+
 //  m_dottedPen = wxPen( "grey", 0, wxDOT );  too slow under XFree86
-    m_dottedPen = wxPen( "grey", 0, 0 );
+    m_dottedPen = wxPen( wxT("grey"), 0, 0 );
 
     return TRUE;
 }
 
 wxGenericTreeCtrl::~wxGenericTreeCtrl()
 {
-    wxDELETE( m_hilightBrush );
+    delete m_hilightBrush;
+    delete m_hilightUnfocusedBrush;
+
+    if (m_arrowRight) delete m_arrowRight;
+    if (m_arrowDown) delete m_arrowDown;
 
     DeleteAllItems();
 
     delete m_renameTimer;
+    if (m_ownsImageListNormal) delete m_imageListNormal;
+    if (m_ownsImageListState) delete m_imageListState;
+    if (m_ownsImageListButtons) delete m_imageListButtons;
 }
 
 // -----------------------------------------------------------------------------
@@ -671,13 +790,13 @@ size_t wxGenericTreeCtrl::GetCount() const
 
 void wxGenericTreeCtrl::SetIndent(unsigned int indent)
 {
-    m_indent = indent;
+    m_indent = (unsigned short) indent;
     m_dirty = TRUE;
 }
 
 void wxGenericTreeCtrl::SetSpacing(unsigned int spacing)
 {
-    m_spacing = spacing;
+    m_spacing = (unsigned short) spacing;
     m_dirty = TRUE;
 }
 
@@ -688,6 +807,15 @@ size_t wxGenericTreeCtrl::GetChildrenCount(const wxTreeItemId& item, bool recurs
     return ((wxGenericTreeItem*) item.m_pItem)->GetChildrenCount(recursively);
 }
 
+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
+    m_windowStyle = styles;
+    m_dirty = TRUE;
+}
+
 // -----------------------------------------------------------------------------
 // functions to work with tree items
 // -----------------------------------------------------------------------------
@@ -797,6 +925,21 @@ void wxGenericTreeCtrl::SetItemFont(const wxTreeItemId& item, const wxFont& font
     RefreshLine(pItem);
 }
 
+bool wxGenericTreeCtrl::SetFont( const wxFont &font )
+{
+    wxScrolledWindow::SetFont(font);
+
+    m_normalFont = font ;
+    m_boldFont = wxFont( m_normalFont.GetPointSize(),
+                            m_normalFont.GetFamily(),
+                            m_normalFont.GetStyle(),
+                            wxBOLD,
+                            m_normalFont.GetUnderlined());
+
+    return TRUE;
+}
+
+
 // -----------------------------------------------------------------------------
 // item status inquiries
 // -----------------------------------------------------------------------------
@@ -805,15 +948,15 @@ bool wxGenericTreeCtrl::IsVisible(const wxTreeItemId& item) const
 {
     wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
 
-       // An item is only visible if it's not a descendant of a collapsed item
+    // An item is only visible if it's not a descendant of a collapsed item
     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
-       wxGenericTreeItem* parent = pItem->GetParent();
-       while (parent)
-       {
-               if (!parent->IsExpanded())
-                       return FALSE;
-               parent = parent->GetParent();
-       }
+    wxGenericTreeItem* parent = pItem->GetParent();
+    while (parent)
+    {
+        if (!parent->IsExpanded())
+            return FALSE;
+        parent = parent->GetParent();
+    }
 
     int startX, startY;
     GetViewStart(& startX, & startY);
@@ -823,8 +966,8 @@ bool wxGenericTreeCtrl::IsVisible(const wxTreeItemId& item) const
     wxRect rect;
     if (!GetBoundingRect(item, rect))
         return FALSE;
-       if (rect.GetWidth() == 0 || rect.GetHeight() == 0)
-               return FALSE;
+    if (rect.GetWidth() == 0 || rect.GetHeight() == 0)
+        return FALSE;
     if (rect.GetBottom() < 0 || rect.GetTop() > clientSize.y)
         return FALSE;
     if (rect.GetRight() < 0 || rect.GetLeft() > clientSize.x)
@@ -837,7 +980,12 @@ bool wxGenericTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const
 {
     wxCHECK_MSG( item.IsOk(), FALSE, wxT("invalid tree item") );
 
-    return !((wxGenericTreeItem*) item.m_pItem)->GetChildren().IsEmpty();
+    // 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
+    // could have them as well and it's better to err on this side rather than
+    // disabling some operations which are restricted to the items with
+    // children for an item which does have them
+    return ((wxGenericTreeItem*) item.m_pItem)->HasPlus();
 }
 
 bool wxGenericTreeCtrl::IsExpanded(const wxTreeItemId& item) const
@@ -867,157 +1015,149 @@ bool wxGenericTreeCtrl::IsBold(const wxTreeItemId& item) const
 
 wxTreeItemId wxGenericTreeCtrl::GetParent(const wxTreeItemId& item) const
 {
-  wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
+    wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
 
-  return ((wxGenericTreeItem*) item.m_pItem)->GetParent();
+    return ((wxGenericTreeItem*) item.m_pItem)->GetParent();
 }
 
 wxTreeItemId wxGenericTreeCtrl::GetFirstChild(const wxTreeItemId& item, long& cookie) const
 {
-  wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
+    wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
 
-  cookie = 0;
-  return GetNextChild(item, cookie);
+    cookie = 0;
+    return GetNextChild(item, cookie);
 }
 
 wxTreeItemId wxGenericTreeCtrl::GetNextChild(const wxTreeItemId& item, long& 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() )
-  {
-    return children.Item((size_t)cookie++);
-  }
-  else
-  {
-    // there are no more of them
-    return wxTreeItemId();
-  }
+    wxArrayGenericTreeItems& children = ((wxGenericTreeItem*) item.m_pItem)->GetChildren();
+    if ( (size_t)cookie < children.Count() )
+    {
+        return children.Item((size_t)cookie++);
+    }
+    else
+    {
+        // there are no more of them
+        return wxTreeItemId();
+    }
 }
 
 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
 {
-  wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
+    wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
 
-  wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
-  wxGenericTreeItem *parent = i->GetParent();
-  if ( parent == NULL )
-  {
-    // root item doesn't have any siblings
-    return wxTreeItemId();
-  }
+    wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
+    wxGenericTreeItem *parent = i->GetParent();
+    if ( parent == NULL )
+    {
+        // root item doesn't have any siblings
+        return wxTreeItemId();
+    }
 
-  wxArrayGenericTreeItems& siblings = parent->GetChildren();
-  int index = siblings.Index(i);
-  wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
+    wxArrayGenericTreeItems& siblings = parent->GetChildren();
+    int index = siblings.Index(i);
+    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]);
+    size_t n = (size_t)(index + 1);
+    return n == siblings.Count() ? wxTreeItemId() : wxTreeItemId(siblings[n]);
 }
 
 wxTreeItemId wxGenericTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const
 {
-  wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
+    wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
 
-  wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
-  wxGenericTreeItem *parent = i->GetParent();
-  if ( parent == NULL )
-  {
-    // root item doesn't have any siblings
-    return wxTreeItemId();
-  }
+    wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
+    wxGenericTreeItem *parent = i->GetParent();
+    if ( parent == NULL )
+    {
+        // root item doesn't have any siblings
+        return wxTreeItemId();
+    }
 
-  wxArrayGenericTreeItems& siblings = parent->GetChildren();
-  int index = siblings.Index(i);
-  wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
+    wxArrayGenericTreeItems& siblings = parent->GetChildren();
+    int index = siblings.Index(i);
+    wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
 
-  return index == 0 ? wxTreeItemId()
-                    : wxTreeItemId(siblings[(size_t)(index - 1)]);
+    return index == 0 ? wxTreeItemId()
+                      : wxTreeItemId(siblings[(size_t)(index - 1)]);
 }
 
 // Only for internal use right now, but should probably be public
 wxTreeItemId wxGenericTreeCtrl::GetNext(const wxTreeItemId& item) const
 {
-  wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
-
-  wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
-
-  // First see if there are any children.
-  wxArrayGenericTreeItems& children = i->GetChildren();
-  if (children.GetCount() > 0)
-  {
-     return children.Item(0);
-  }
-  else
-  {
-     // Try a sibling of this or ancestor instead
-     wxTreeItemId p = item;
-     wxTreeItemId toFind;
-     do
-     {
-        toFind = GetNextSibling(p);
-        p = GetParent(p);
-     } while (p.IsOk() && !toFind.IsOk());
-     return toFind;
-  }
-}
-
-wxTreeItemId wxGenericTreeCtrl::GetPrev(const wxTreeItemId& item) const
-{
-  wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
+    wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
 
-  wxFAIL_MSG(wxT("not implemented"));
+    wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
 
-  return wxTreeItemId();
+    // First see if there are any children.
+    wxArrayGenericTreeItems& children = i->GetChildren();
+    if (children.GetCount() > 0)
+    {
+         return children.Item(0);
+    }
+    else
+    {
+         // Try a sibling of this or ancestor instead
+         wxTreeItemId p = item;
+         wxTreeItemId toFind;
+         do
+         {
+              toFind = GetNextSibling(p);
+              p = GetParent(p);
+         } while (p.IsOk() && !toFind.IsOk());
+         return toFind;
+    }
 }
 
 wxTreeItemId wxGenericTreeCtrl::GetFirstVisibleItem() const
 {
-  wxTreeItemId id = GetRootItem();
-  if (!id.IsOk())
-    return id;
-
-  do
-  {
-    if (IsVisible(id))
+    wxTreeItemId id = GetRootItem();
+    if (!id.IsOk())
         return id;
-    id = GetNext(id);
-  } while (id.IsOk());
 
-  return wxTreeItemId();
+    do
+    {
+        if (IsVisible(id))
+              return id;
+        id = GetNext(id);
+    } while (id.IsOk());
+
+    return wxTreeItemId();
 }
 
 wxTreeItemId wxGenericTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
 {
-  wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
+    wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
 
-  wxTreeItemId id = item;
-  while (id.IsOk())
-  {
-         id = GetNext(id);
-
-         if (id.IsOk() && IsVisible(id))
-                 return id;
-  }
-  return wxTreeItemId();
+    wxTreeItemId id = item;
+    if (id.IsOk())
+    {
+        while (id = GetNext(id), id.IsOk())
+        {
+            if (IsVisible(id))
+                return id;
+        }
+    }
+    return wxTreeItemId();
 }
 
 wxTreeItemId wxGenericTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
 {
-  wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
+    wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
 
-  wxFAIL_MSG(wxT("not implemented"));
+    wxFAIL_MSG(wxT("not implemented"));
 
-  return wxTreeItemId();
+    return wxTreeItemId();
 }
 
 // -----------------------------------------------------------------------------
@@ -1037,9 +1177,10 @@ wxTreeItemId wxGenericTreeCtrl::DoInsertItem(const wxTreeItemId& parentId,
         return AddRoot(text, image, selImage, data);
     }
 
-    wxClientDC dc(this);
+    m_dirty = TRUE;     // do this first so stuff below doesn't cause flicker
+
     wxGenericTreeItem *item =
-        new wxGenericTreeItem( parent, text, dc, image, selImage, data );
+        new wxGenericTreeItem( parent, text, image, selImage, data );
 
     if ( data != NULL )
     {
@@ -1048,8 +1189,6 @@ wxTreeItemId wxGenericTreeCtrl::DoInsertItem(const wxTreeItemId& parentId,
 
     parent->Insert( item, previous );
 
-    m_dirty = TRUE;
-
     return item;
 }
 
@@ -1059,22 +1198,29 @@ wxTreeItemId wxGenericTreeCtrl::AddRoot(const wxString& text,
 {
     wxCHECK_MSG( !m_anchor, wxTreeItemId(), wxT("tree can have only one root") );
 
-    wxClientDC dc(this);
-    m_anchor = new wxGenericTreeItem((wxGenericTreeItem *)NULL, text, dc,
+    m_dirty = TRUE;     // do this first so stuff below doesn't cause flicker
+
+    m_anchor = new wxGenericTreeItem((wxGenericTreeItem *)NULL, text,
                                    image, selImage, data);
     if ( data != NULL )
     {
         data->m_pItem = (long) m_anchor;
     }
 
+    if (HasFlag(wxTR_HIDE_ROOT))
+    {
+        // if root is hidden, make sure we can navigate
+        // into children
+        m_anchor->SetHasPlus();
+        Expand(m_anchor);
+    }
+
     if (!HasFlag(wxTR_MULTIPLE))
     {
         m_current = m_key_current = m_anchor;
         m_current->SetHilight( TRUE );
     }
 
-    m_dirty = TRUE;
-
     return m_anchor;
 }
 
@@ -1148,31 +1294,31 @@ void wxGenericTreeCtrl::SendDeleteEvent(wxGenericTreeItem *item)
 
 void wxGenericTreeCtrl::DeleteChildren(const wxTreeItemId& itemId)
 {
+    m_dirty = TRUE;     // do this first so stuff below doesn't cause flicker
+
     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
     item->DeleteChildren(this);
-
-    m_dirty = TRUE;
 }
 
 void wxGenericTreeCtrl::Delete(const wxTreeItemId& itemId)
 {
+    m_dirty = TRUE;     // do this first so stuff below doesn't cause flicker
+
     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
 
-    // don't stay with invalid m_key_current or we will crash in the next call
-    // to OnChar()
+    // 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 && !changeKeyCurrent )
+    while ( itemKey )
     {
         if ( itemKey == item )
         {
             // m_key_current is a descendant of the item being deleted
             changeKeyCurrent = TRUE;
+            break;
         }
-        else
-        {
-            itemKey = itemKey->GetParent();
-        }
+        itemKey = itemKey->GetParent();
     }
 
     wxGenericTreeItem *parent = item->GetParent();
@@ -1190,20 +1336,18 @@ void wxGenericTreeCtrl::Delete(const wxTreeItemId& itemId)
     item->DeleteChildren(this);
     SendDeleteEvent(item);
     delete item;
-
-    m_dirty = TRUE;
 }
 
 void wxGenericTreeCtrl::DeleteAllItems()
 {
     if ( m_anchor )
     {
+        m_dirty = TRUE;
+
         m_anchor->DeleteChildren(this);
         delete m_anchor;
 
         m_anchor = NULL;
-
-        m_dirty = TRUE;
     }
 }
 
@@ -1272,12 +1416,14 @@ void wxGenericTreeCtrl::Collapse(const wxTreeItemId& itemId)
 
     item->Collapse();
 
+#if 0  // TODO why should items be collapsed recursively?
     wxArrayGenericTreeItems& children = item->GetChildren();
     size_t count = children.Count();
     for ( size_t n = 0; n < count; n++ )
     {
         Collapse(children[n]);
     }
+#endif
 
     CalculatePositions();
 
@@ -1333,7 +1479,13 @@ void wxGenericTreeCtrl::UnselectAllChildren(wxGenericTreeItem *item)
 
 void wxGenericTreeCtrl::UnselectAll()
 {
-    UnselectAllChildren((wxGenericTreeItem*) GetRootItem().m_pItem);
+    wxTreeItemId rootItem = GetRootItem();
+
+    // the tree might not have the root item at all
+    if ( rootItem )
+    {
+        UnselectAllChildren((wxGenericTreeItem*) rootItem.m_pItem);
+    }
 }
 
 // Recursive function !
@@ -1444,7 +1596,18 @@ void wxGenericTreeCtrl::SelectItem(const wxTreeItemId& itemId,
     // TODO : Here we don't send any selection mode yet !
 
     if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() )
-      return;
+        return;
+
+    wxTreeItemId parent = GetParent( itemId );
+    while (parent.IsOk())
+    {
+        if (!IsExpanded(parent))
+            Expand( parent );
+
+        parent = GetParent( parent );
+    }
+
+    EnsureVisible( itemId );
 
     // ctrl press
     if (unselect_others)
@@ -1458,8 +1621,7 @@ void wxGenericTreeCtrl::SelectItem(const wxTreeItemId& itemId,
     {
         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)
@@ -1471,7 +1633,7 @@ void wxGenericTreeCtrl::SelectItem(const wxTreeItemId& itemId,
 
         // Check if we need to toggle hilight (ctrl mode)
         if (!unselect_others)
-          select=!item->IsSelected();
+            select=!item->IsSelected();
 
         m_current = m_key_current = item;
         m_current->SetHilight(select);
@@ -1499,15 +1661,15 @@ void wxGenericTreeCtrl::FillArray(wxGenericTreeItem *item,
 
 size_t wxGenericTreeCtrl::GetSelections(wxArrayTreeItemIds &array) const
 {
-  array.Empty();
-  wxTreeItemId idRoot = GetRootItem();
-  if ( idRoot.IsOk() )
-  {
-      FillArray((wxGenericTreeItem*) idRoot.m_pItem, array);
-  }
-  //else: the tree is empty, so no selections
+    array.Empty();
+    wxTreeItemId idRoot = GetRootItem();
+    if ( idRoot.IsOk() )
+    {
+        FillArray((wxGenericTreeItem*) idRoot.m_pItem, array);
+    }
+    //else: the tree is empty, so no selections
 
-  return array.Count();
+    return array.Count();
 }
 
 void wxGenericTreeCtrl::EnsureVisible(const wxTreeItemId& item)
@@ -1536,7 +1698,7 @@ void wxGenericTreeCtrl::ScrollTo(const wxTreeItemId &item)
     // 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) wxYield();
+    if (m_dirty) wxYieldIfNeeded();
 
     wxGenericTreeItem *gitem = (wxGenericTreeItem*) item.m_pItem;
 
@@ -1545,7 +1707,7 @@ void wxGenericTreeCtrl::ScrollTo(const wxTreeItemId &item)
 
     int start_x = 0;
     int start_y = 0;
-    ViewStart( &start_x, &start_y );
+    GetViewStart( &start_x, &start_y );
     start_y *= PIXELS_PER_UNIT;
 
     int client_h = 0;
@@ -1608,11 +1770,11 @@ void wxGenericTreeCtrl::SortChildren(const wxTreeItemId& itemId)
     wxArrayGenericTreeItems& children = item->GetChildren();
     if ( children.Count() > 1 )
     {
+        m_dirty = TRUE;
+
         s_treeBeingSorted = this;
         children.Sort(tree_ctrl_compare_func);
         s_treeBeingSorted = NULL;
-
-        m_dirty = TRUE;
     }
     //else: don't make the tree dirty as nothing changed
 }
@@ -1622,41 +1784,96 @@ wxImageList *wxGenericTreeCtrl::GetImageList() const
     return m_imageListNormal;
 }
 
+wxImageList *wxGenericTreeCtrl::GetButtonsImageList() const
+{
+    return m_imageListButtons;
+}
+
 wxImageList *wxGenericTreeCtrl::GetStateImageList() const
 {
     return m_imageListState;
 }
 
-void wxGenericTreeCtrl::SetImageList(wxImageList *imageList)
+void wxGenericTreeCtrl::CalculateLineHeight()
 {
-    m_imageListNormal = imageList;
-
-    if ( !m_imageListNormal )
-        return;
-
-    // Calculate a m_lineHeight value from the image sizes.
-    // May be toggle off. Then wxGenericTreeCtrl will spread when
-    // necessary (which might look ugly).
     wxClientDC dc(this);
     m_lineHeight = (int)(dc.GetCharHeight() + 4);
-    int width = 0, height = 0,
-        n = m_imageListNormal->GetImageCount();
 
-    for (int i = 0; i < n ; i++)
+    if ( m_imageListNormal )
     {
-        m_imageListNormal->GetSize(i, width, height);
-        if (height > m_lineHeight) m_lineHeight = height;
+        // Calculate a m_lineHeight value from the normal Image sizes.
+        // May be toggle off. Then wxGenericTreeCtrl will spread when
+        // necessary (which might look ugly).
+        int n = m_imageListNormal->GetImageCount();
+        for (int i = 0; i < n ; i++)
+        {
+            int width = 0, height = 0;
+            m_imageListNormal->GetSize(i, width, height);
+            if (height > m_lineHeight) m_lineHeight = height;
+        }
+    }
+
+    if (m_imageListButtons)
+    {
+        // Calculate a m_lineHeight value from the Button image sizes.
+        // May be toggle off. Then wxGenericTreeCtrl will spread when
+        // necessary (which might look ugly).
+        int n = m_imageListButtons->GetImageCount();
+        for (int i = 0; i < n ; i++)
+        {
+            int width = 0, height = 0;
+            m_imageListButtons->GetSize(i, width, height);
+            if (height > m_lineHeight) m_lineHeight = height;
+        }
     }
 
-    if (m_lineHeight < 40)
+    if (m_lineHeight < 30)
         m_lineHeight += 2;                 // at least 2 pixels
     else
         m_lineHeight += m_lineHeight/10;   // otherwise 10% extra spacing
 }
 
+void wxGenericTreeCtrl::SetImageList(wxImageList *imageList)
+{
+    if (m_ownsImageListNormal) delete m_imageListNormal;
+    m_imageListNormal = imageList;
+    m_ownsImageListNormal = FALSE;
+    m_dirty = TRUE;
+    CalculateLineHeight();
+}
+
 void wxGenericTreeCtrl::SetStateImageList(wxImageList *imageList)
 {
+    if (m_ownsImageListState) delete m_imageListState;
     m_imageListState = imageList;
+    m_ownsImageListState = FALSE;
+}
+
+void wxGenericTreeCtrl::SetButtonsImageList(wxImageList *imageList)
+{
+    if (m_ownsImageListButtons) delete m_imageListButtons;
+    m_imageListButtons = imageList;
+    m_ownsImageListButtons = FALSE;
+    m_dirty = TRUE;
+    CalculateLineHeight();
+}
+
+void wxGenericTreeCtrl::AssignImageList(wxImageList *imageList)
+{
+    SetImageList(imageList);
+    m_ownsImageListNormal = TRUE;
+}
+
+void wxGenericTreeCtrl::AssignStateImageList(wxImageList *imageList)
+{
+    SetStateImageList(imageList);
+    m_ownsImageListState = TRUE;
+}
+
+void wxGenericTreeCtrl::AssignButtonsImageList(wxImageList *imageList)
+{
+    SetButtonsImageList(imageList);
+    m_ownsImageListButtons = TRUE;
 }
 
 // -----------------------------------------------------------------------------
@@ -1667,8 +1884,7 @@ void wxGenericTreeCtrl::AdjustMyScrollbars()
 {
     if (m_anchor)
     {
-        int x = 0;
-        int y = 0;
+        int x = 0, 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
@@ -1692,18 +1908,18 @@ int wxGenericTreeCtrl::GetLineHeight(wxGenericTreeItem *item) const
 
 void wxGenericTreeCtrl::PaintItem(wxGenericTreeItem *item, wxDC& dc)
 {
+    // TODO implement "state" icon on items
+
     wxTreeItemAttr *attr = item->GetAttributes();
     if ( attr && attr->HasFont() )
         dc.SetFont(attr->GetFont());
     else if (item->IsBold())
         dc.SetFont(m_boldFont);
 
-    long text_w = 0;
-    long text_h = 0;
+    long text_w = 0, text_h = 0;
     dc.GetTextExtent( item->GetText(), &text_w, &text_h );
 
-    int image_h = 0;
-    int image_w = 0;
+    int image_h = 0, image_w = 0;
     int image = item->GetCurrentImage();
     if ( image != NO_IMAGE )
     {
@@ -1720,8 +1936,10 @@ void wxGenericTreeCtrl::PaintItem(wxGenericTreeItem *item, wxDC& dc)
 
     int total_h = GetLineHeight(item);
 
-    if (item->IsSelected())
-        dc.SetBrush(*m_hilightBrush);
+    if ( item->IsSelected() )
+    {
+        dc.SetBrush(*(m_hasFocus ? m_hilightBrush : m_hilightUnfocusedBrush));
+    }
     else
     {
         wxColour colBg;
@@ -1732,7 +1950,32 @@ void wxGenericTreeCtrl::PaintItem(wxGenericTreeItem *item, wxDC& dc)
         dc.SetBrush(wxBrush(colBg, wxSOLID));
     }
 
-    dc.DrawRectangle( item->GetX()-2, item->GetY(), item->GetWidth()+2, total_h );
+    int offset = HasFlag(wxTR_ROW_LINES) ? 1 : 0;
+
+    if ( HasFlag(wxTR_FULL_ROW_HIGHLIGHT) )
+    {
+        int x, y, w, h;
+
+        DoGetPosition(&x, &y);
+        DoGetSize(&w, &h);
+        dc.DrawRectangle(x, item->GetY()+offset, w, total_h-offset);
+    }
+    else
+    {
+        if ( item->IsSelected() && 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 );
+        }
+        else
+        {
+            dc.DrawRectangle( item->GetX()-2, item->GetY()+offset,
+                              item->GetWidth()+2, total_h-offset );
+        }
+    }
 
     if ( image != NO_IMAGE )
     {
@@ -1757,66 +2000,69 @@ void wxGenericTreeCtrl::PaintItem(wxGenericTreeItem *item, wxDC& dc)
 // 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 )
 {
-    int horizX = level*m_indent;
-
-    item->SetX( horizX+m_indent+m_spacing );
-    item->SetY( y );
+    int x = level*m_indent;
+    if (!HasFlag(wxTR_HIDE_ROOT))
+    {
+        x += m_indent;
+    }
+    else if (level == 0)
+    {
+        // always expand hidden root
+        int origY = y;
+        wxArrayGenericTreeItems& children = item->GetChildren();
+        int count = children.Count();
+        if (count > 0)
+        {
+            int n = 0, oldY;
+            do {
+                oldY = y;
+                PaintLevel(children[n], dc, 1, y);
+            } while (++n < count);
 
-    int oldY = y;
-    y+=GetLineHeight(item)/2;
+            if (!HasFlag(wxTR_NO_LINES) && HasFlag(wxTR_LINES_AT_ROOT) && count > 0)
+            {
+                // draw line down to last child
+                origY += GetLineHeight(children[0])>>1;
+                oldY += GetLineHeight(children[n-1])>>1;
+                dc.DrawLine(3, origY, 3, oldY);
+            }
+        }
+        return;
+    }
 
-    item->SetCross( horizX+m_indent, y );
+    item->SetX(x+m_spacing);
+    item->SetY(y);
 
-    int exposed_x = dc.LogicalToDeviceX( 0 );
-    int exposed_y = dc.LogicalToDeviceY( item->GetY() );
+    int h = GetLineHeight(item);
+    int y_top = y;
+    int y_mid = y_top + (h>>1);
+    y += h;
 
-    bool drawLines = ((GetWindowStyle() & wxTR_NO_LINES) == 0);
+    int exposed_x = dc.LogicalToDeviceX(0);
+    int exposed_y = dc.LogicalToDeviceY(y_top);
 
-    if (IsExposed( exposed_x, exposed_y, 10000, GetLineHeight(item) ))  // 10000 = very much
+    if (IsExposed(exposed_x, exposed_y, 10000, h))  // 10000 = very much
     {
-        int startX = horizX;
-        int endX = horizX + (m_indent-5);
+        wxPen *pen =
+#ifndef __WXMAC__
+            // don't draw rect outline if we already have the
+            // background color under Mac
+            (item->IsSelected() && m_hasFocus) ? wxBLACK_PEN :
+#endif // !__WXMAC__
+            wxTRANSPARENT_PEN;
 
-//        if (!item->HasChildren()) endX += (m_indent+5);
-        if (!item->HasChildren()) endX += 20;
-
-        if (drawLines)
-            dc.DrawLine( startX, y, endX, y );
-
-        if (item->HasPlus())
-        {
-            if (drawLines)
-                dc.DrawLine( horizX+(m_indent+5), y, horizX+(m_indent+15), y );
-            dc.SetPen( *wxGREY_PEN );
-            dc.SetBrush( *wxWHITE_BRUSH );
-            dc.DrawRectangle( horizX+(m_indent-5), y-4, 11, 9 );
-
-            dc.SetPen( *wxBLACK_PEN );
-            dc.DrawLine( horizX+(m_indent-2), y, horizX+(m_indent+3), y );
-            if (!item->IsExpanded())
-                dc.DrawLine( horizX+m_indent, y-2, horizX+m_indent, y+3 );
-
-            dc.SetPen( m_dottedPen );
-        }
-
-        wxPen *pen = wxTRANSPARENT_PEN;
         wxColour colText;
-
         if ( item->IsSelected() )
         {
-            colText = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_HIGHLIGHTTEXT );
-
-            if ( m_hasFocus )
-               pen = wxBLACK_PEN;
-
+            colText = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
         }
         else
         {
             wxTreeItemAttr *attr = item->GetAttributes();
-            if ( attr && attr->HasTextColour() )
+            if (attr && attr->HasTextColour())
                 colText = attr->GetTextColour();
             else
-                colText = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_WINDOWTEXT );
+                colText = GetForegroundColour();
         }
 
         // prepare to draw
@@ -1826,35 +2072,131 @@ void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level
         // draw
         PaintItem(item, dc);
 
+        if (HasFlag(wxTR_ROW_LINES))
+        {
+            // if the background colour is white, choose a
+            // contrasting color for the lines
+            dc.SetPen(*((GetBackgroundColour() == *wxWHITE)
+                         ? wxMEDIUM_GREY_PEN : wxWHITE_PEN));
+            dc.DrawLine(0, y_top, 10000, y_top);
+            dc.DrawLine(0, y, 10000, y);
+        }
+
         // restore DC objects
-        dc.SetBrush( *wxWHITE_BRUSH );
-        dc.SetPen( m_dottedPen );
-        dc.SetTextForeground( *wxBLACK );
-    }
+        dc.SetBrush(*wxWHITE_BRUSH);
+        dc.SetPen(m_dottedPen);
+        dc.SetTextForeground(*wxBLACK);
 
-    y = oldY+GetLineHeight(item);
+        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 (item->IsExpanded())
-    {
-        oldY+=GetLineHeight(item)/2;
-        int semiOldY=0;
+            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
 
-        wxArrayGenericTreeItems& children = item->GetChildren();
-        size_t n, count = children.Count();
-        for ( n = 0; n < count; ++n )
+                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?
         {
-            semiOldY=y;
-            PaintLevel( children[n], dc, level+1, y );
+            // draw the horizontal line here
+            int x_start = x;
+            if (x > (signed)m_indent)
+                x_start -= m_indent;
+            else if (HasFlag(wxTR_LINES_AT_ROOT))
+                x_start = 3;
+            dc.DrawLine(x_start, y_mid, x + m_spacing, y_mid);
         }
+    }
 
-        // it may happen that the item is expanded but has no items (when you
-        // delete all its children for example) - don't draw the vertical line
-        // in this case
+    if (item->IsExpanded())
+    {
+        wxArrayGenericTreeItems& children = item->GetChildren();
+        int count = children.Count();
         if (count > 0)
         {
-            semiOldY+=GetLineHeight(children[--n])/2;
-            if (drawLines)
-                dc.DrawLine( horizX+m_indent, oldY+5, horizX+m_indent, semiOldY );
+            int n = 0, oldY;
+            ++level;
+            do {
+                oldY = y;
+                PaintLevel(children[n], dc, level, y);
+            } while (++n < count);
+
+            if (!HasFlag(wxTR_NO_LINES) && count > 0)
+            {
+                // draw line down to last child
+                oldY += GetLineHeight(children[n-1])>>1;
+                if (HasButtons()) y_mid += 5;
+                dc.DrawLine(x, y_mid, x, oldY);
+            }
         }
     }
 }
@@ -1944,26 +2286,34 @@ void wxGenericTreeCtrl::OnPaint( wxPaintEvent &WXUNUSED(event) )
     PaintLevel( m_anchor, dc, 0, y );
 }
 
-void wxGenericTreeCtrl::OnSetFocus( wxFocusEvent &WXUNUSED(event) )
+void wxGenericTreeCtrl::OnSetFocus( wxFocusEvent &event )
 {
     m_hasFocus = TRUE;
 
-    if (m_current) RefreshLine( m_current );
+    RefreshSelected();
+
+    event.Skip();
 }
 
-void wxGenericTreeCtrl::OnKillFocus( wxFocusEvent &WXUNUSED(event) )
+void wxGenericTreeCtrl::OnKillFocus( wxFocusEvent &event )
 {
     m_hasFocus = FALSE;
 
-    if (m_current) RefreshLine( m_current );
+    RefreshSelected();
+
+    event.Skip();
 }
 
 void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
 {
     wxTreeEvent te( wxEVT_COMMAND_TREE_KEY_DOWN, GetId() );
-    te.m_code = (int)event.KeyCode();
+    te.m_evtKey = event;
     te.SetEventObject( this );
-    GetEventHandler()->ProcessEvent( te );
+    if ( GetEventHandler()->ProcessEvent( te ) )
+    {
+        // intercepted by the user code
+        return;
+    }
 
     if ( (m_current == 0) || (m_key_current == 0) )
     {
@@ -2021,25 +2371,29 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
             {
                 wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
                 event.m_item = (long) m_current;
-                event.m_code = 0;
                 event.SetEventObject( this );
                 GetEventHandler()->ProcessEvent( event );
             }
             break;
 
-            // up goes to the previous sibling or to the last of its children if
-            // it's expanded
+            // up goes to the previous sibling or to the last
+            // of its children if it's expanded
         case WXK_UP:
             {
                 wxTreeItemId prev = GetPrevSibling( m_key_current );
                 if (!prev)
                 {
                     prev = GetParent( m_key_current );
+                    if ((prev == GetRootItem()) && HasFlag(wxTR_HIDE_ROOT))
+                    {
+                        break;  // don't go to root if it is hidden
+                    }
                     if (prev)
                     {
-                        long cockie = 0;
+                        long cookie = 0;
                         wxTreeItemId current = m_key_current;
-                        if (current == GetFirstChild( prev, cockie ))
+                        // 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
                             SelectItem( prev, unselect_others, extended_select );
@@ -2071,6 +2425,11 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
         case WXK_LEFT:
             {
                 wxTreeItemId prev = GetParent( m_current );
+                if ((prev == GetRootItem()) && HasFlag(wxTR_HIDE_ROOT))
+                {
+                    // don't go to root if it is hidden
+                    prev = GetPrevSibling( m_current );
+                }
                 if (prev)
                 {
                     EnsureVisible( prev );
@@ -2080,8 +2439,8 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
             break;
 
         case WXK_RIGHT:
-            // this works the same as the down arrow except that we also expand the
-            // item if it wasn't expanded yet
+            // this works the same as the down arrow except that we
+            // also expand the item if it wasn't expanded yet
             Expand(m_current);
             // fall through
 
@@ -2147,11 +2506,15 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
         case WXK_HOME:
             {
                 wxTreeItemId prev = GetRootItem();
-                if (prev)
+                if (!prev) break;
+                if (HasFlag(wxTR_HIDE_ROOT))
                 {
-                    EnsureVisible( prev );
-                    SelectItem( prev, unselect_others, extended_select );
+                    long dummy;
+                    prev = GetFirstChild(prev, dummy);
+                    if (!prev) break;
                 }
+                EnsureVisible( prev );
+                SelectItem( prev, unselect_others, extended_select );
             }
             break;
 
@@ -2162,31 +2525,38 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
 
 wxTreeItemId wxGenericTreeCtrl::HitTest(const wxPoint& point, int& flags)
 {
-    // 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) wxYield();
+    // JACS: removed wxYieldIfNeeded() because it can cause the window
+    // to be deleted from under us if a close window event is pending
 
-    wxClientDC dc(this);
-    PrepareDC(dc);
-    wxCoord x = dc.DeviceToLogicalX( point.x );
-    wxCoord y = dc.DeviceToLogicalY( point.y );
     int w, h;
     GetSize(&w, &h);
-
     flags=0;
-    if (point.x<0) flags|=wxTREE_HITTEST_TOLEFT;
-    if (point.x>w) flags|=wxTREE_HITTEST_TORIGHT;
-    if (point.y<0) flags|=wxTREE_HITTEST_ABOVE;
-    if (point.y>h) flags|=wxTREE_HITTEST_BELOW;
+    if (point.x<0) flags |= wxTREE_HITTEST_TOLEFT;
+    if (point.x>w) flags |= wxTREE_HITTEST_TORIGHT;
+    if (point.y<0) flags |= wxTREE_HITTEST_ABOVE;
+    if (point.y>h) flags |= wxTREE_HITTEST_BELOW;
+    if (flags) return wxTreeItemId();
+
+    if (m_anchor == NULL)
+    {
+        flags = wxTREE_HITTEST_NOWHERE;
+        return wxTreeItemId();
+    }
 
-    return m_anchor->HitTest( wxPoint(x, y), this, flags);
+    wxGenericTreeItem *hit =  m_anchor->HitTest(CalcUnscrolledPosition(point),
+                                                this, flags, 0);
+    if (hit == NULL)
+    {
+        flags = wxTREE_HITTEST_NOWHERE;
+        return wxTreeItemId();
+    }
+    return hit;
 }
 
 // get the bounding rectangle of the item (or of its label only)
 bool wxGenericTreeCtrl::GetBoundingRect(const wxTreeItemId& item,
                          wxRect& rect,
-                         bool textOnly) const
+                         bool WXUNUSED(textOnly)) const
 {
     wxCHECK_MSG( item.IsOk(), FALSE, _T("invalid item in wxGenericTreeCtrl::GetBoundingRect") );
 
@@ -2196,10 +2566,10 @@ bool wxGenericTreeCtrl::GetBoundingRect(const wxTreeItemId& item,
     GetViewStart(& startX, & startY);
 
     rect.x = i->GetX() - startX*PIXELS_PER_UNIT;
-       rect.y = i->GetY() - startY*PIXELS_PER_UNIT;
+    rect.y = i->GetY() - startY*PIXELS_PER_UNIT;
     rect.width = i->GetWidth();
-       //rect.height = i->GetHeight();
-       rect.height = GetLineHeight(i);
+    //rect.height = i->GetHeight();
+    rect.height = GetLineHeight(i);
 
     return TRUE;
 }
@@ -2222,13 +2592,13 @@ void wxGenericTreeCtrl::Edit( const wxTreeItemId& item )
     // 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) wxYield();
+    if (m_dirty) wxYieldIfNeeded();
 
     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();
+    int x, y;
+    CalcScrolledPosition(m_currentEdit->GetX(), m_currentEdit->GetY(), &x, &y);
 
     int image_h = 0;
     int image_w = 0;
@@ -2249,13 +2619,13 @@ void wxGenericTreeCtrl::Edit( const wxTreeItemId& item )
     x += image_w;
     w -= image_w + 4; // I don't know why +4 is needed
 
-    wxClientDC dc(this);
-    PrepareDC( dc );
-    x = dc.LogicalToDeviceX( x );
-    y = dc.LogicalToDeviceY( y );
-
-    wxTreeTextCtrl *text = new wxTreeTextCtrl(
-      this, -1, &m_renameAccept, &m_renameRes, this, s, wxPoint(x-4,y-4), wxSize(w+11,h+8) );
+    wxTreeTextCtrl *text = new wxTreeTextCtrl(this, -1,
+                                              &m_renameAccept,
+                                              &m_renameRes,
+                                              this,
+                                              s,
+                                              wxPoint(x-4,y-4),
+                                              wxSize(w+11,h+8));
     text->SetFocus();
 }
 
@@ -2266,6 +2636,7 @@ void wxGenericTreeCtrl::OnRenameTimer()
 
 void wxGenericTreeCtrl::OnRenameAccept()
 {
+    // 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 );
@@ -2296,18 +2667,15 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
         return;
     }
 
-    wxClientDC dc(this);
-    PrepareDC(dc);
-    wxCoord x = dc.DeviceToLogicalX( event.GetX() );
-    wxCoord y = dc.DeviceToLogicalY( event.GetY() );
+    wxPoint pt = CalcUnscrolledPosition(event.GetPosition());
 
     int flags = 0;
-    wxGenericTreeItem *item = m_anchor->HitTest( wxPoint(x,y), this, flags);
+    wxGenericTreeItem *item = m_anchor->HitTest(pt, this, flags, 0);
 
     if ( event.Dragging() && !m_isDragging )
     {
         if (m_dragCount == 0)
-            m_dragStart = wxPoint(x,y);
+            m_dragStart = pt;
 
         m_dragCount++;
 
@@ -2365,7 +2733,7 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
             // highlight the current drop target if any
             DrawDropEffect(m_dropTarget);
 
-            wxYield();
+            wxYieldIfNeeded();
         }
     }
     else if ( (event.LeftUp() || event.RightUp()) && m_isDragging )
@@ -2373,11 +2741,18 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
         // erase the highlighting
         DrawDropEffect(m_dropTarget);
 
+        if ( m_oldSelection )
+        {
+            m_oldSelection->SetHilight(TRUE);
+            RefreshLine(m_oldSelection);
+            m_oldSelection = (wxGenericTreeItem *)NULL;
+        }
+
         // 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.m_pointDrag = pt;
         event.SetEventObject(this);
 
         (void)GetEventHandler()->ProcessEvent(event);
@@ -2385,18 +2760,11 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
         m_isDragging = FALSE;
         m_dropTarget = (wxGenericTreeItem *)NULL;
 
-        if ( m_oldSelection )
-        {
-            m_oldSelection->SetHilight(TRUE);
-            RefreshLine(m_oldSelection);
-            m_oldSelection = (wxGenericTreeItem *)NULL;
-        }
-
         ReleaseMouse();
 
         SetCursor(m_oldCursor);
 
-        wxYield();
+        wxYieldIfNeeded();
     }
     else
     {
@@ -2410,7 +2778,7 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
         {
             wxTreeEvent nevent(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK, GetId());
             nevent.m_item = (long) item;
-            nevent.m_code = 0;
+            nevent.m_pointDrag = CalcScrolledPosition(pt);
             nevent.SetEventObject(this);
             GetEventHandler()->ProcessEvent(nevent);
         }
@@ -2422,19 +2790,35 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
                      (flags & wxTREE_HITTEST_ONITEMLABEL) &&
                      HasFlag(wxTR_EDIT_LABELS) )
                 {
+                    if ( m_renameTimer->IsRunning() )
+                        m_renameTimer->Stop();
+
                     m_renameTimer->Start( 100, TRUE );
                 }
 
                 m_lastOnSame = FALSE;
             }
         }
-        else
+        else // !RightDown() && !LeftUp() ==> LeftDown() || LeftDClick()
         {
             if ( event.LeftDown() )
             {
                 m_lastOnSame = item == m_current;
             }
 
+            if ( flags & wxTREE_HITTEST_ONITEMBUTTON )
+            {
+                // only toggle the item for a single click, double click on
+                // the button doesn't do anything (it toggles the item twice)
+                if ( event.LeftDown() )
+                {
+                    Toggle( item );
+                }
+
+                // don't select the item if the button was clicked
+                return;
+            }
+
             // how should the selection work for this event?
             bool is_multiple, extended_select, unselect_others;
             EventFlagsToSelType(GetWindowStyleFlag(),
@@ -2442,26 +2826,31 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
                                 event.ControlDown(),
                                 is_multiple, extended_select, unselect_others);
 
-            if ( (flags & wxTREE_HITTEST_ONITEMBUTTON) && event.LeftDown() )
-            {
-                Toggle( item );
-                if ( is_multiple )
-                    return;
-            }
-
             SelectItem(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
                 m_renameTimer->Stop();
                 m_lastOnSame = FALSE;
 
+                // send activate event first
                 wxTreeEvent nevent( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
                 nevent.m_item = (long) item;
-                nevent.m_code = 0;
+                nevent.m_pointDrag = CalcScrolledPosition(pt);
                 nevent.SetEventObject( this );
-                GetEventHandler()->ProcessEvent( nevent );
+                if ( !GetEventHandler()->ProcessEvent( nevent ) )
+                {
+                    // if the user code didn't process the activate event,
+                    // handle it ourselves by toggling the item when it is
+                    // double clicked
+                    if ( item->HasPlus() )
+                    {
+                        Toggle(item);
+                    }
+                }
             }
         }
     }
@@ -2472,8 +2861,7 @@ 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;
+    if (!m_dirty) return;
 
     m_dirty = FALSE;
 
@@ -2487,7 +2875,10 @@ void wxGenericTreeCtrl::CalculateSize( wxGenericTreeItem *item, wxDC &dc )
     wxCoord text_w = 0;
     wxCoord text_h = 0;
 
-    if (item->IsBold())
+    wxTreeItemAttr *attr = item->GetAttributes();
+    if ( attr && attr->HasFont() )
+        dc.SetFont(attr->GetFont());
+    else if ( item->IsBold() )
         dc.SetFont(m_boldFont);
 
     dc.GetTextExtent( item->GetText(), &text_w, &text_h );
@@ -2510,7 +2901,7 @@ void wxGenericTreeCtrl::CalculateSize( wxGenericTreeItem *item, wxDC &dc )
 
     int total_h = (image_h > text_h) ? image_h : text_h;
 
-    if (total_h < 40)
+    if (total_h < 30)
         total_h += 2;            // at least 2 pixels
     else
         total_h += total_h/10;   // otherwise 10% extra spacing
@@ -2527,25 +2918,37 @@ void wxGenericTreeCtrl::CalculateSize( wxGenericTreeItem *item, wxDC &dc )
 // not the middle of it !
 void wxGenericTreeCtrl::CalculateLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y )
 {
-    int horizX = level*m_indent;
+    int x = level*m_indent;
+    if (!HasFlag(wxTR_HIDE_ROOT))
+    {
+        x += m_indent;
+    }
+    else if (level == 0)
+    {
+        // a hidden root is not evaluated, but its
+        // children are always calculated
+        goto Recurse;
+    }
 
     CalculateSize( item, dc );
 
     // set its position
-    item->SetX( horizX+m_indent+m_spacing );
+    item->SetX( x+m_spacing );
     item->SetY( y );
-    y+=GetLineHeight(item);
+    y += GetLineHeight(item);
 
     if ( !item->IsExpanded() )
     {
-        // we dont need to calculate collapsed branches
+        // we don't need to calculate collapsed branches
         return;
     }
 
+  Recurse:
     wxArrayGenericTreeItems& children = item->GetChildren();
     size_t n, count = children.Count();
+    ++level;
     for (n = 0; n < count; ++n )
-        CalculateLevel( children[n], dc, level+1, y );  // recurse
+        CalculateLevel( children[n], dc, level, y );  // recurse
 }
 
 void wxGenericTreeCtrl::CalculatePositions()
@@ -2569,20 +2972,14 @@ void wxGenericTreeCtrl::RefreshSubtree(wxGenericTreeItem *item)
 {
     if (m_dirty) return;
 
-    wxClientDC dc(this);
-    PrepareDC(dc);
-
-    int cw = 0;
-    int ch = 0;
-    GetClientSize( &cw, &ch );
+    wxSize client = GetClientSize();
 
     wxRect rect;
-    rect.x = dc.LogicalToDeviceX( 0 );
-    rect.width = cw;
-    rect.y = dc.LogicalToDeviceY( item->GetY() );
-    rect.height = ch;
+    CalcScrolledPosition(0, item->GetY(), &rect.x, &rect.y);
+    rect.width = client.x;
+    rect.height = client.y;
 
-    Refresh( TRUE, &rect );
+    Refresh(TRUE, &rect);
 
     AdjustMyScrollbars();
 }
@@ -2591,19 +2988,57 @@ void wxGenericTreeCtrl::RefreshLine( wxGenericTreeItem *item )
 {
     if (m_dirty) return;
 
-    wxClientDC dc(this);
-    PrepareDC( dc );
-
-    int cw = 0;
-    int ch = 0;
-    GetClientSize( &cw, &ch );
-
     wxRect rect;
-    rect.x = dc.LogicalToDeviceX( 0 );
-    rect.y = dc.LogicalToDeviceY( item->GetY() );
-    rect.width = cw;
+    CalcScrolledPosition(0, item->GetY(), &rect.x, &rect.y);
+    rect.width = GetClientSize().x;
     rect.height = GetLineHeight(item); //dc.GetCharHeight() + 6;
 
-    Refresh( TRUE, &rect );
+    Refresh(TRUE, &rect);
+}
+
+void wxGenericTreeCtrl::RefreshSelected()
+{
+    // TODO: this is awfully inefficient, we should keep the list of all
+    //       selected items internally, should be much faster
+    if ( m_anchor )
+        RefreshSelectedUnder(m_anchor);
+}
+
+void wxGenericTreeCtrl::RefreshSelectedUnder(wxGenericTreeItem *item)
+{
+    if ( item->IsSelected() )
+        RefreshLine(item);
+
+    const wxArrayGenericTreeItems& children = item->GetChildren();
+    size_t count = children.GetCount();
+    for ( size_t n = 0; n < count; n++ )
+    {
+        RefreshSelectedUnder(children[n]);
+    }
+}
+
+// ----------------------------------------------------------------------------
+// changing colours: we need to refresh the tree control
+// ----------------------------------------------------------------------------
+
+bool wxGenericTreeCtrl::SetBackgroundColour(const wxColour& colour)
+{
+    if ( !wxWindow::SetBackgroundColour(colour) )
+        return FALSE;
+
+    Refresh();
+
+    return TRUE;
+}
+
+bool wxGenericTreeCtrl::SetForegroundColour(const wxColour& colour)
+{
+    if ( !wxWindow::SetForegroundColour(colour) )
+        return FALSE;
+
+    Refresh();
+
+    return TRUE;
 }
 
+#endif // wxUSE_TREECTRL