adapting keycode field usage for EVT_CHAR in unicode to MSW variant (full unicode...

[wxWidgets.git] / src / generic / treectlg.cpp

diff --git a/src/generic/treectlg.cpp b/src/generic/treectlg.cpp
index 61d3d2e8ab12e7bc1889aa8ca0aefc83b6f9a118..2e2650bfed959324dc2f106afce9c13b13fe13dc 100644 (file)
--- a/src/generic/treectlg.cpp
+++ b/src/generic/treectlg.cpp
@@ -5,7 +5,7 @@
 // Created:     01/02/97
 // Modified:    22/10/98 - almost total rewrite, simpler interface (VZ)
 // Id:          $Id$
 // 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,26 +17,29 @@
 // headers
 // -----------------------------------------------------------------------------
 
 // headers
 // -----------------------------------------------------------------------------
 

-#ifdef __GNUG__
-  #pragma implementation "treectlg.h"
-#endif
-

 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__

-#pragma hdrstop
+    #pragma hdrstop

 #endif
 
 #endif
 

+#if wxUSE_TREECTRL
+
+#include "wx/treebase.h"
+#include "wx/treectrl.h"

 #include "wx/generic/treectlg.h"
 #include "wx/generic/treectlg.h"

+#include "wx/timer.h"
+#include "wx/textctrl.h"

 #include "wx/imaglist.h"
 #include "wx/settings.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/dcclient.h"

-#include "wx/msgdlg.h"
+
+#include "wx/renderer.h"
+
+#ifdef __WXMAC__
+    #include "wx/mac/private.h"
+#endif

 
 // -----------------------------------------------------------------------------
 // array types
 
 // -----------------------------------------------------------------------------
 // array types


@@ -44,8 +47,7 @@
 
 class WXDLLEXPORT wxGenericTreeItem;
 
 
 class WXDLLEXPORT wxGenericTreeItem;
 

-WX_DEFINE_EXPORTED_ARRAY(wxGenericTreeItem *, wxArrayGenericTreeItems);
-//WX_DEFINE_OBJARRAY(wxArrayTreeItemIds);
+WX_DEFINE_EXPORTED_ARRAY_PTR(wxGenericTreeItem *, wxArrayGenericTreeItems);

 
 // ----------------------------------------------------------------------------
 // constants
 
 // ----------------------------------------------------------------------------
 // constants


@@ -53,7 +55,10 @@ WX_DEFINE_EXPORTED_ARRAY(wxGenericTreeItem *, wxArrayGenericTreeItems);
 
 static const int NO_IMAGE = -1;
 
 
 static const int NO_IMAGE = -1;
 

-#define PIXELS_PER_UNIT 10
+static const int PIXELS_PER_UNIT = 10;
+
+// the margin between the item image and the item text
+static const int MARGIN_BETWEEN_IMAGE_AND_TEXT = 4;

 
 // -----------------------------------------------------------------------------
 // private classes
 
 // -----------------------------------------------------------------------------
 // private classes


@@ -63,43 +68,86 @@ static const int NO_IMAGE = -1;
 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;
+
+    DECLARE_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() { }
-    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 = false)
+    {
+        if ( discardChanges )
+        {
+            StopEditing();
+        }
+        else
+        {
+            m_aboutToFinish = true;
+
+            // Notify the owner about the changes
+            AcceptChanges();

 
 

+            // Even if vetoed, close the control (consistent with MSW)
+            Finish();
+        }
+    }
+
+    void StopEditing()
+    {
+        Finish();
+        m_owner->OnRenameCancelled(m_itemEdited);
+    }
+    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();
+

 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()

-    DECLARE_DYNAMIC_CLASS(wxTreeTextCtrl);
+    DECLARE_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;
+
+    DECLARE_NO_COPY_CLASS(wxTreeFindTimer)

 };
 
 // a tree item
 };
 
 // a tree item


@@ -109,10 +157,10 @@ public:
     // ctors & dtor
     wxGenericTreeItem() { m_data = NULL; }
     wxGenericTreeItem( wxGenericTreeItem *parent,
     // 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();
 
 
     ~wxGenericTreeItem();
 


@@ -132,7 +180,7 @@ public:
     void SetImage(int image, wxTreeItemIcon which) { m_images[which] = image; }
     void SetData(wxTreeItemData *data) { m_data = data; }
 
     void SetImage(int image, wxTreeItemIcon which) { m_images[which] = image; }
     void SetData(wxTreeItemData *data) { m_data = data; }
 

-    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; }
 


@@ -148,34 +196,33 @@ public:
     void SetHeight(int h) { m_height = h; }
     void SetWidth(int w) { m_width = w; }
 
     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);
     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')
 
     // 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)
     { m_children.Insert(child, index); }
 
 
     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
     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);
+        // 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 );

 
 

-    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(); }


@@ -191,36 +238,57 @@ public:
     wxTreeItemAttr& Attr()
     {
         if ( !m_attr )
     wxTreeItemAttr& Attr()
     {
         if ( !m_attr )

+        {

             m_attr = new wxTreeItemAttr;
             m_attr = new wxTreeItemAttr;

-
+            m_ownsAttr = true;
+        }

         return *m_attr;
     }
         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:
 
 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];
 
 
     // tree ctrl images for the normal, selected, expanded and
     // expanded+selected states
     int                 m_images[wxTreeItemIcon_Max];
 

-    wxTreeItemData     *m_data;
+    wxCoord             m_x;            // (virtual) offset from top
+    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
-
-    wxCoord             m_x, m_y;
-    wxCoord             m_height, m_width;
-    int                 m_xCross, m_yCross;
-    int                 m_level;
+    unsigned int        m_isBold      :1; // render the label in bold font
+    unsigned int        m_ownsAttr    :1; // delete attribute when done

 
 

-    wxArrayGenericTreeItems m_children;
-    wxGenericTreeItem  *m_parent;
-
-    wxTreeItemAttr     *m_attr;
+    DECLARE_NO_COPY_CLASS(wxGenericTreeItem)

 };
 
 // =============================================================================
 };
 
 // =============================================================================


@@ -245,6 +313,23 @@ 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)
 // -----------------------------------------------------------------------------


@@ -263,101 +348,156 @@ void wxTreeRenameTimer::Notify()
 // wxTreeTextCtrl (internal)
 //-----------------------------------------------------------------------------
 
 // 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()
 
 BEGIN_EVENT_TABLE(wxTreeTextCtrl,wxTextCtrl)
     EVT_CHAR           (wxTreeTextCtrl::OnChar)
     EVT_KEY_UP         (wxTreeTextCtrl::OnKeyUp)
     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;
+
+    int w = m_itemEdited->GetWidth(),
+        h = m_itemEdited->GetHeight();
+
+    int x, y;
+    m_owner->CalcScrolledPosition(item->GetX(), item->GetY(), &x, &y);
+
+    int image_h = 0,
+        image_w = 0;
+
+    int image = item->GetCurrentImage();
+    if ( image != NO_IMAGE )
+    {
+        if ( m_owner->m_imageListNormal )
+        {
+            m_owner->m_imageListNormal->GetSize( image, image_w, image_h );
+            image_w += MARGIN_BETWEEN_IMAGE_AND_TEXT;
+        }
+        else
+        {
+            wxFAIL_MSG(_T("you must create an image list to use images!"));
+        }
+    }
+
+    // FIXME: what are all these hardcoded 4, 8 and 11s really?
+    x += image_w;
+    w -= image_w + 4;
+#ifdef __WXMAC__
+    wxSize bs = DoGetBestSize() ;
+    // edit control height
+    if ( h > bs.y - 8 )
+    {
+        int diff = h - ( bs.y - 8 ) ;
+        h -= diff ;
+        y += diff / 2 ;
+    }
+#endif
+
+    (void)Create(m_owner, wxID_ANY, m_startValue,
+                 wxPoint(x - 4, y - 4), wxSize(w + 11, h + 8));

 }
 
 }
 

-void wxTreeTextCtrl::OnChar( wxKeyEvent &event )
+bool wxTreeTextCtrl::AcceptChanges()

 {
 {

-    if (event.m_keyCode == WXK_RETURN)
+    const wxString value = GetValue();
+
+    if ( value == m_startValue )

     {
     {

-        (*m_accept) = TRUE;
-        (*m_res) = GetValue();
-        
-        if (!wxPendingDelete.Member(this))
-            wxPendingDelete.Append(this);
+        // 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

 
 

-        if ((*m_accept) && ((*m_res) != m_startValue))
-            m_owner->OnRenameAccept();
-            
-        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) = "";
-        
-        if (!wxPendingDelete.Member(this))
-            wxPendingDelete.Append(this);
-            
-        return;
+        // vetoed by the user
+        return false;

     }
     }

-    event.Skip();
+
+    // accepted, do rename the item
+    m_owner->SetItemText(m_itemEdited, value);
+
+    return true;

 }
 
 }
 

-void wxTreeTextCtrl::OnKeyUp( wxKeyEvent &event )
+void wxTreeTextCtrl::Finish()

 {
 {

-    // auto-grow the textctrl:
-    wxSize parentSize = m_owner->GetSize();
-    wxPoint myPos = GetPosition();
-    wxSize mySize = GetSize();
-    int sx, sy;
-    GetTextExtent(GetValue() + _T("MM"), &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 ( !m_finished  )
+    {
+        m_owner->ResetTextControl();
+
+        wxPendingDelete.Append(this);
+
+        m_finished = true;
+
+        m_owner->SetFocus();
+    }

 }
 
 }
 

-void wxTreeTextCtrl::OnKillFocus( wxFocusEvent &WXUNUSED(event) )
+void wxTreeTextCtrl::OnChar( wxKeyEvent &event )

 {
 {

-    if (!wxPendingDelete.Member(this))
-        wxPendingDelete.Append(this);
+    switch ( event.m_keyCode )
+    {
+        case WXK_RETURN:
+            EndEdit();
+            break;
+
+        case WXK_ESCAPE:
+            StopEditing();
+            break;

 
 

-    if ((*m_accept) && ((*m_res) != m_startValue))
-        m_owner->OnRenameAccept();
+        default:
+            event.Skip();
+    }

 }
 
 }
 

-#if 0
-// -----------------------------------------------------------------------------
-// wxTreeEvent
-// -----------------------------------------------------------------------------
+void wxTreeTextCtrl::OnKeyUp( wxKeyEvent &event )
+{
+    if ( !m_finished )
+    {
+        // 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, wxDefaultCoord);
+    }

 
 

-IMPLEMENT_DYNAMIC_CLASS(wxTreeEvent, wxNotifyEvent)
+    event.Skip();
+}

 
 

-wxTreeEvent::wxTreeEvent( wxEventType commandType, int id )
-           : wxNotifyEvent( commandType, id )
+void wxTreeTextCtrl::OnKillFocus( wxFocusEvent &event )

 {
 {

-    m_code = 0;
-    m_itemOld = (wxGenericTreeItem *)NULL;
+    if ( !m_finished && !m_aboutToFinish )
+    {
+        // We must finish regardless of success, otherwise we'll get
+        // focus problems:
+        Finish();
+
+        if ( !AcceptChanges() )
+            m_owner->OnRenameCancelled( m_itemEdited );
+    }
+
+    // We must let the native text control handle focus, too, otherwise
+    // it could have problems with the cursor (e.g., in wxGTK).
+    event.Skip();

 }
 }

-#endif

 
 // -----------------------------------------------------------------------------
 // wxGenericTreeItem
 
 // -----------------------------------------------------------------------------
 // wxGenericTreeItem


@@ -365,7 +505,6 @@ wxTreeEvent::wxTreeEvent( wxEventType commandType, int id )
 
 wxGenericTreeItem::wxGenericTreeItem(wxGenericTreeItem *parent,
                                      const wxString& text,
 
 wxGenericTreeItem::wxGenericTreeItem(wxGenericTreeItem *parent,
                                      const wxString& text,

-                                     wxDC& WXUNUSED(dc),

                                      int image, int selImage,
                                      wxTreeItemData *data)
                  : m_text(text)
                                      int image, int selImage,
                                      wxTreeItemData *data)
                  : m_text(text)


@@ -377,18 +516,16 @@ wxGenericTreeItem::wxGenericTreeItem(wxGenericTreeItem *parent,
 
     m_data = data;
     m_x = m_y = 0;
 
     m_data = data;
     m_x = m_y = 0;

-    m_xCross = m_yCross = 0;

 
 

-    m_level = 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_attr = (wxTreeItemAttr *)NULL;
 
     m_parent = parent;
 
     m_attr = (wxTreeItemAttr *)NULL;

+    m_ownsAttr = false;

 
     // We don't know the height here yet.
     m_width = 0;
 
     // We don't know the height here yet.
     m_width = 0;


@@ -399,7 +536,7 @@ wxGenericTreeItem::~wxGenericTreeItem()
 {
     delete m_data;
 
 {
     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") );
 
     wxASSERT_MSG( m_children.IsEmpty(),
                   wxT("please call DeleteChildren() before deleting the item") );


@@ -415,6 +552,8 @@ void wxGenericTreeItem::DeleteChildren(wxGenericTreeCtrl *tree)
             tree->SendDeleteEvent(child);
 
         child->DeleteChildren(tree);
             tree->SendDeleteEvent(child);
 
         child->DeleteChildren(tree);

+        if (child == tree->m_select_me)
+            tree->m_select_me = NULL;

         delete child;
     }
 
         delete child;
     }
 


@@ -426,28 +565,6 @@ void wxGenericTreeItem::SetText( const wxString &text )
     m_text = 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();
 size_t wxGenericTreeItem::GetChildrenCount(bool recursively) const
 {
     size_t count = m_children.Count();


@@ -463,15 +580,10 @@ size_t wxGenericTreeItem::GetChildrenCount(bool recursively) const
     return total;
 }
 
     return total;
 }
 

-void wxGenericTreeItem::SetCross( int x, int y )
-{
-    m_xCross = x;
-    m_yCross = y;
-}
-
-void wxGenericTreeItem::GetSize( int &x, int &y, const wxGenericTreeCtrl *theTree )
+void wxGenericTreeItem::GetSize( int &x, int &y,
+                                 const wxGenericTreeCtrl *theButton )

 {
 {

-    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;
     if ( y < bottomY ) y = bottomY;
     int width = m_x +  m_width;
     if ( x < width ) x = width;


@@ -481,71 +593,89 @@ void wxGenericTreeItem::GetSize( int &x, int &y, const wxGenericTreeCtrl *theTre
         size_t count = m_children.Count();
         for ( size_t n = 0; n < count; ++n )
         {
         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;
+
+            int xCross = m_x - theCtrl->GetSpacing();
+#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() )
+#endif
+            {
+                flags |= wxTREE_HITTEST_ONITEMBUTTON;
+                return this;
+            }

 
 

-        if ((point.x >= m_x) && (point.x <= m_x+m_width))
-        {
-            int image_w = -1;
-            int image_h;
+            if ((point.x >= m_x) && (point.x <= m_x+m_width))
+            {
+                int image_w = -1;
+                int image_h;

 
 

-            // 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);
+                // 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;
+                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;
         }
 
 
             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;
 }
 
     return (wxGenericTreeItem*) NULL;
 }
 


@@ -572,12 +702,9 @@ int wxGenericTreeItem::GetCurrentImage() const
             image = GetImage(wxTreeItemIcon_Selected);
     }
 
             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;
 }
 
     return image;
 }


@@ -586,18 +713,18 @@ int wxGenericTreeItem::GetCurrentImage() const
 // 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_MOUSE_EVENTS   (wxGenericTreeCtrl::OnMouse)
     EVT_CHAR           (wxGenericTreeCtrl::OnChar)
     EVT_SET_FOCUS      (wxGenericTreeCtrl::OnSetFocus)
     EVT_KILL_FOCUS     (wxGenericTreeCtrl::OnKillFocus)
     EVT_PAINT          (wxGenericTreeCtrl::OnPaint)
     EVT_MOUSE_EVENTS   (wxGenericTreeCtrl::OnMouse)
     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__)
+#if !defined(__WXMSW__) || defined(__WXUNIVERSAL__)

 /*
  * wxTreeCtrl has to be a real class or we have problems with
  * the run-time information.
 /*
  * wxTreeCtrl has to be a real class or we have problems with
  * the run-time information.


@@ -614,71 +741,123 @@ void wxGenericTreeCtrl::Init()
 {
     m_current =
     m_key_current =
 {
     m_current =
     m_key_current =

-    m_anchor = (wxGenericTreeItem *) NULL;
-    m_hasFocus = FALSE;
-    m_dirty = FALSE;
+    m_anchor =
+    m_select_me = (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
     m_lineHeight = 10;
     m_indent = 15;
     m_spacing = 18;
 
     m_hilightBrush = new wxBrush

-    (
-      wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHT),
-      wxSOLID
-    );
-
-    m_imageListNormal =
-    m_imageListState = (wxImageList *) NULL;
-    m_ownsImageListNormal = 
-    m_ownsImageListState = FALSE;
+                         (
+                            wxSystemSettings::GetColour
+                            (
+                                wxSYS_COLOUR_HIGHLIGHT
+                            ),
+                            wxSOLID
+                         );
+
+    m_hilightUnfocusedBrush = new wxBrush
+                              (
+                                 wxSystemSettings::GetColour
+                                 (
+                                     wxSYS_COLOUR_BTNSHADOW
+                                 ),
+                                 wxSOLID
+                              );
+
+    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_freezeCount = 0;
+
+    m_findTimer = NULL;
+
+    m_dropEffectAboveItem = false;

 
 

-    m_renameTimer = new wxTreeRenameTimer( this );
-    m_lastOnSame = FALSE;
+    m_lastOnSame = false;

 
 

-    m_normalFont = wxSystemSettings::GetSystemFont( wxSYS_DEFAULT_GUI_FONT );
-    m_boldFont = wxFont( m_normalFont.GetPointSize(),
-                            m_normalFont.GetFamily(),
-                            m_normalFont.GetStyle(),
-                            wxBOLD,
-                            m_normalFont.GetUnderlined());
+#ifdef __WXMAC_CARBON__
+    m_normalFont.MacCreateThemeFont( kThemeViewsFont ) ;
+#else
+    m_normalFont = wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT );
+#endif
+    m_boldFont = wxFont(m_normalFont.GetPointSize(),
+                        m_normalFont.GetFamily(),
+                        m_normalFont.GetStyle(),
+                        wxBOLD,
+                        m_normalFont.GetUnderlined(),
+                        m_normalFont.GetFaceName(),
+                        m_normalFont.GetEncoding());

 }
 
 }
 

-bool wxGenericTreeCtrl::Create(wxWindow *parent, wxWindowID id,
-                        const wxPoint& pos, const wxSize& size,
-                        long style,
-                        const wxValidator &validator,
-                        const wxString& name )
+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 );
+#ifdef __WXMAC__
+    int major,minor;
+    wxGetOsVersion( &major, &minor );

 
 

-#if wxUSE_VALIDATORS
-    SetValidator( validator );
-#endif
+    style &= ~wxTR_LINES_AT_ROOT;
+    style |= wxTR_NO_LINES;
+    if (major < 10)
+        style |= wxTR_ROW_LINES;
+#endif // __WXMAC__
+
+    if ( !wxControl::Create( parent, id, pos, size,
+                             style|wxHSCROLL|wxVSCROLL,
+                             validator,
+                             name ) )
+        return false;
+
+    // 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;
+    }
+
+    wxVisualAttributes attr = GetDefaultAttributes();
+    SetOwnForegroundColour( attr.colFg );
+    SetOwnBackgroundColour( attr.colBg );
+    if (!m_hasFont)
+        SetOwnFont(attr.font);
+
+    m_dottedPen = wxPen( wxT("grey"), 0, 0 );

 
 

-    SetBackgroundColour( wxSystemSettings::GetSystemColour( wxSYS_COLOUR_LISTBOX ) );
-//  m_dottedPen = wxPen( "grey", 0, wxDOT );  too slow under XFree86
-    m_dottedPen = wxPen( "grey", 0, 0 );
+    SetBestSize(size);

 
 

-    return TRUE;
+    return true;

 }
 
 wxGenericTreeCtrl::~wxGenericTreeCtrl()
 {
 }
 
 wxGenericTreeCtrl::~wxGenericTreeCtrl()
 {

-    wxDELETE( m_hilightBrush );
+    delete m_hilightBrush;
+    delete m_hilightUnfocusedBrush;

 
     DeleteAllItems();
 
     delete m_renameTimer;
 
     DeleteAllItems();
 
     delete m_renameTimer;

-    if (m_ownsImageListNormal) delete m_imageListNormal;
-    if (m_ownsImageListState) delete m_imageListState;
+    delete m_findTimer;
+
+    if (m_ownsImageListButtons)
+        delete m_imageListButtons;

 }
 
 // -----------------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------------


@@ -687,26 +866,53 @@ wxGenericTreeCtrl::~wxGenericTreeCtrl()
 
 size_t wxGenericTreeCtrl::GetCount() const
 {
 
 size_t wxGenericTreeCtrl::GetCount() const
 {

-    return m_anchor == NULL ? 0u : m_anchor->GetChildrenCount();
+    if ( !m_anchor )
+    {
+        // the tree is empty
+        return 0;
+    }
+
+    size_t count = m_anchor->GetChildrenCount();
+    if ( !HasFlag(wxTR_HIDE_ROOT) )
+    {
+        // take the root itself into account
+        count++;
+    }
+
+    return count;

 }
 
 void wxGenericTreeCtrl::SetIndent(unsigned int indent)
 {
 }
 
 void wxGenericTreeCtrl::SetIndent(unsigned int indent)
 {

-    m_indent = indent;
-    m_dirty = TRUE;
+    m_indent = (unsigned short) indent;
+    m_dirty = true;

 }
 
 }
 

-void wxGenericTreeCtrl::SetSpacing(unsigned int spacing)
+size_t
+wxGenericTreeCtrl::GetChildrenCount(const wxTreeItemId& item,
+                                    bool recursively) const

 {
 {

-    m_spacing = spacing;
-    m_dirty = TRUE;
+    wxCHECK_MSG( item.IsOk(), 0u, wxT("invalid tree item") );
+
+    return ((wxGenericTreeItem*) item.m_pItem)->GetChildrenCount(recursively);

 }
 
 }
 

-size_t wxGenericTreeCtrl::GetChildrenCount(const wxTreeItemId& item, bool recursively)
+void wxGenericTreeCtrl::SetWindowStyle(const long styles)

 {
 {

-    wxCHECK_MSG( item.IsOk(), 0u, wxT("invalid tree item") );
+    // 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();
+    }

 
 

-    return ((wxGenericTreeItem*) item.m_pItem)->GetChildrenCount(recursively);
+    // 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;

 }
 
 // -----------------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------------


@@ -715,7 +921,7 @@ size_t wxGenericTreeCtrl::GetChildrenCount(const wxTreeItemId& item, bool recurs
 
 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();
 }


@@ -735,6 +941,30 @@ wxTreeItemData *wxGenericTreeCtrl::GetItemData(const wxTreeItemId& item) const
     return ((wxGenericTreeItem*) item.m_pItem)->GetData();
 }
 
     return ((wxGenericTreeItem*) item.m_pItem)->GetData();
 }
 

+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") );
 void wxGenericTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text)
 {
     wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );


@@ -764,6 +994,9 @@ void wxGenericTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *da
 {
     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);
 }
 


@@ -789,6 +1022,25 @@ void wxGenericTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
     }
 }
 
     }
 }
 

+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)
 {


@@ -818,23 +1070,40 @@ void wxGenericTreeCtrl::SetItemFont(const wxTreeItemId& item, const wxFont& font
     RefreshLine(pItem);
 }
 
     RefreshLine(pItem);
 }
 

+bool wxGenericTreeCtrl::SetFont( const wxFont &font )
+{
+    wxTreeCtrlBase::SetFont(font);
+
+    m_normalFont = font ;
+    m_boldFont = wxFont(m_normalFont.GetPointSize(),
+                        m_normalFont.GetFamily(),
+                        m_normalFont.GetStyle(),
+                        wxBOLD,
+                        m_normalFont.GetUnderlined(),
+                        m_normalFont.GetFaceName(),
+                        m_normalFont.GetEncoding());
+
+    return true;
+}
+
+

 // -----------------------------------------------------------------------------
 // item status inquiries
 // -----------------------------------------------------------------------------
 
 bool wxGenericTreeCtrl::IsVisible(const wxTreeItemId& item) const
 {
 // -----------------------------------------------------------------------------
 // item status inquiries
 // -----------------------------------------------------------------------------
 
 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
+    // An item is only visible if it's not a descendant of a collapsed item

     wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
     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);
 
     int startX, startY;
     GetViewStart(& startX, & startY);


@@ -843,41 +1112,46 @@ bool wxGenericTreeCtrl::IsVisible(const wxTreeItemId& item) const
 
     wxRect rect;
     if (!GetBoundingRect(item, rect))
 
     wxRect rect;
     if (!GetBoundingRect(item, rect))

-        return FALSE;
-       if (rect.GetWidth() == 0 || rect.GetHeight() == 0)
-               return FALSE;
+        return false;
+    if (rect.GetWidth() == 0 || rect.GetHeight() == 0)
+        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") );

 
 

-    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
 {
 }
 
 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();
 }


@@ -886,159 +1160,239 @@ 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") );
+    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
+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") );

 
 

-  cookie = 0;
-  return GetNextChild(item, cookie);
+    cookie = 0;
+    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() )
-  {
-    return children.Item((size_t)cookie++);
-  }
-  else
-  {
-    // there are no more of them
-    return wxTreeItemId();
-  }
+    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.Count() )
+    {
+        return children.Item((*pIndex)++);
+    }
+    else
+    {
+        // there are no more of them
+        return wxTreeItemId();
+    }
+}
+
+#if WXWIN_COMPATIBILITY_2_4
+
+wxTreeItemId wxGenericTreeCtrl::GetFirstChild(const wxTreeItemId& item,
+                                              long& cookie) const
+{
+    wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
+
+    cookie = 0;
+    return GetNextChild(item, cookie);
+}
+
+wxTreeItemId wxGenericTreeCtrl::GetNextChild(const wxTreeItemId& item,
+                                             long& cookie) const
+{
+    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();
+    }

 }
 
 }
 

+#endif // WXWIN_COMPATIBILITY_2_4
+

 wxTreeItemId wxGenericTreeCtrl::GetLastChild(const wxTreeItemId& item) const
 {
 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
 {

-  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
 {
 }
 
 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
 {
 }
 
 // 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") );
+    wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );

 
 

-  wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
+    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;
-  }
+    // 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 = GetItemParent(p);
+         } while (p.IsOk() && !toFind.IsOk());
+         return toFind;
+    }

 }
 
 }
 

-wxTreeItemId wxGenericTreeCtrl::GetPrev(const wxTreeItemId& item) const
+wxTreeItemId wxGenericTreeCtrl::GetFirstVisibleItem() const

 {
 {

-  wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
+    wxTreeItemId id = GetRootItem();
+    if (!id.IsOk())
+        return id;

 
 

-  wxFAIL_MSG(wxT("not implemented"));
+    do
+    {
+        if (IsVisible(id))
+              return id;
+        id = GetNext(id);
+    } while (id.IsOk());

 
 

-  return wxTreeItemId();
+    return wxTreeItemId();

 }
 
 }
 

-wxTreeItemId wxGenericTreeCtrl::GetFirstVisibleItem() const
+wxTreeItemId wxGenericTreeCtrl::GetNextVisible(const wxTreeItemId& item) const

 {
 {

-  wxTreeItemId id = GetRootItem();
-  if (!id.IsOk())
-    return id;
-
-  do
-  {
-    if (IsVisible(id))
-        return id;
-    id = GetNext(id);
-  } while (id.IsOk());
+    wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );

 
 

-  return wxTreeItemId();
+    wxTreeItemId id = item;
+    if (id.IsOk())
+    {
+        while (id = GetNext(id), id.IsOk())
+        {
+            if (IsVisible(id))
+                return id;
+        }
+    }
+    return wxTreeItemId();

 }
 
 }
 

-wxTreeItemId wxGenericTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
+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") );

 
 

-  wxTreeItemId id = item;
-  while (id.IsOk())
-  {
-         id = GetNext(id);
+    wxFAIL_MSG(wxT("not implemented"));

 
 

-         if (id.IsOk() && IsVisible(id))
-                 return id;
-  }
-  return wxTreeItemId();
+    return wxTreeItemId();

 }
 
 }
 

-wxTreeItemId wxGenericTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
+// called by wxTextTreeCtrl when it marks itself for deletion
+void wxGenericTreeCtrl::ResetTextControl()

 {
 {

-  wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
+    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 id = idParent;
+    if ( prefix.length() == 1 )
+    {
+        id = GetNext(id);
+    }
+
+    // look for the item starting with the given prefix after it
+    while ( id.IsOk() && !GetItemText(id).Lower().StartsWith(prefix) )
+    {
+        id = GetNext(id);
+    }
+
+    // if we haven't found anything...
+    if ( !id.IsOk() )
+    {
+        // ... wrap to the beginning
+        id = GetRootItem();
+        if ( HasFlag(wxTR_HIDE_ROOT) )
+        {
+            // can't select virtual root
+            id = GetNext(id);
+        }

 
 

-  wxFAIL_MSG(wxT("not implemented"));
+        // and try all the items (stop when we get to the one we started from)
+        while ( id != idParent && !GetItemText(id).Lower().StartsWith(prefix) )
+        {
+            id = GetNext(id);
+        }
+    }

 
 

-  return wxTreeItemId();
+    return id;

 }
 
 // -----------------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------------


@@ -1046,10 +1400,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 )


@@ -1058,60 +1413,61 @@ wxTreeItemId wxGenericTreeCtrl::DoInsertItem(const wxTreeItemId& parentId,
         return AddRoot(text, image, selImage, data);
     }
 
         return AddRoot(text, image, selImage, data);
     }
 

-    wxClientDC dc(this);
+    m_dirty = true;     // do this first so stuff below doesn't cause flicker
+

     wxGenericTreeItem *item =
     wxGenericTreeItem *item =

-        new wxGenericTreeItem( parent, text, dc, image, selImage, data );
+        new wxGenericTreeItem( parent, text, image, selImage, data );

 
     if ( data != NULL )
     {
 
     if ( data != NULL )
     {

-        data->m_pItem = (long) item;
+        data->m_pItem = item;

     }
 
     }
 

-    parent->Insert( item, previous );
-
-    m_dirty = TRUE;
+    parent->Insert( item, previous == (size_t)-1 ? parent->GetChildren().size()
+                                                 : previous );

 
     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(), 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 )
     {
                                    image, selImage, data);
     if ( data != NULL )
     {

-        data->m_pItem = (long) m_anchor;
+        data->m_pItem = m_anchor;
+    }
+
+    if (HasFlag(wxTR_HIDE_ROOT))
+    {
+        // if root is hidden, make sure we can navigate
+        // into children
+        m_anchor->SetHasPlus();
+        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 );

     }
 
     }
 

-    m_dirty = TRUE;
-

     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 )


@@ -1120,111 +1476,123 @@ 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") );
-
-    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 )
+    int index = -1;
+    if (idPrevious.IsOk())

     {
     {

-        // should we give a warning here?
-        return AddRoot(text, image, selImage, data);
+        index = parent->GetChildren().Index((wxGenericTreeItem*) idPrevious.m_pItem);
+        wxASSERT_MSG( index != wxNOT_FOUND,
+                      wxT("previous item in wxGenericTreeCtrl::InsertItem() is not a sibling") );

     }
 
     }
 

-    return DoInsertItem(parentId, before, text, image, selImage, data);
+    return DoInsertItem(parentId, (size_t)++index, text, image, selImage, data);

 }
 
 }
 

-wxTreeItemId wxGenericTreeCtrl::AppendItem(const wxTreeItemId& parentId,
-                                    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( parent, parent->GetChildren().Count(), text,
-                         image, selImage, data);
-}

 
 void wxGenericTreeCtrl::SendDeleteEvent(wxGenericTreeItem *item)
 {
     wxTreeEvent event( wxEVT_COMMAND_TREE_DELETE_ITEM, GetId() );
 
 void wxGenericTreeCtrl::SendDeleteEvent(wxGenericTreeItem *item)
 {
     wxTreeEvent event( wxEVT_COMMAND_TREE_DELETE_ITEM, GetId() );

-    event.m_item = (long) item;
+    event.m_item = item;

     event.SetEventObject( this );
     ProcessEvent( event );
 }
 
     event.SetEventObject( this );
     ProcessEvent( event );
 }
 

+// Don't leave edit or selection on a child which is about to disappear
+void wxGenericTreeCtrl::ChildrenClosing(wxGenericTreeItem* item)
+{
+    if (m_textCtrl != NULL && item != m_textCtrl->item() && IsDescendantOf(item, m_textCtrl->item())) {
+        m_textCtrl->StopEditing();
+    }
+    if (item != m_key_current && IsDescendantOf(item, m_key_current)) {
+        m_key_current = NULL;
+    }
+    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
+

     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;

+    ChildrenClosing(item);

     item->DeleteChildren(this);
     item->DeleteChildren(this);

-
-    m_dirty = TRUE;

 }
 
 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
+

     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 && !changeKeyCurrent )
+    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;
-        }
-        else
-        {
-            itemKey = itemKey->GetParent();
-        }
+        // can't delete the item being edited, cancel editing it first
+        m_textCtrl->StopEditing();

     }
 
     wxGenericTreeItem *parent = item->GetParent();
     }
 
     wxGenericTreeItem *parent = item->GetParent();

+
+    // 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 = parent;
+    }
+
+    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 = parent;
+    }
+
+    // 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);

-    delete item;

 
 

-    m_dirty = TRUE;
+    if (item == m_select_me)
+        m_select_me = NULL;
+
+    delete item;

 }
 
 void wxGenericTreeCtrl::DeleteAllItems()
 {
     if ( m_anchor )
     {
 }
 
 void wxGenericTreeCtrl::DeleteAllItems()
 {
     if ( m_anchor )
     {

-        m_anchor->DeleteChildren(this);
-        delete m_anchor;
-
-        m_anchor = NULL;
-
-        m_dirty = TRUE;
+        Delete(m_anchor);

     }
 }
 
     }
 }
 


@@ -1233,6 +1601,8 @@ void wxGenericTreeCtrl::Expand(const wxTreeItemId& itemId)
     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
 
     wxCHECK_RET( item, _T("invalid item in wxGenericTreeCtrl::Expand") );
     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
 
     wxCHECK_RET( item, _T("invalid item in wxGenericTreeCtrl::Expand") );

+    wxCHECK_RET( !HasFlag(wxTR_HIDE_ROOT) || itemId != GetRootItem(),
+                 _T("can't expand hidden root") );

 
     if ( !item->HasPlus() )
         return;
 
     if ( !item->HasPlus() )
         return;


@@ -1241,7 +1611,7 @@ void wxGenericTreeCtrl::Expand(const wxTreeItemId& itemId)
         return;
 
     wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_EXPANDING, GetId() );
         return;
 
     wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_EXPANDING, GetId() );

-    event.m_item = (long) item;
+    event.m_item = item;

     event.SetEventObject( this );
 
     if ( ProcessEvent( event ) && !event.IsAllowed() )
     event.SetEventObject( this );
 
     if ( ProcessEvent( event ) && !event.IsAllowed() )


@@ -1261,29 +1631,35 @@ void wxGenericTreeCtrl::Expand(const wxTreeItemId& itemId)
 
 void wxGenericTreeCtrl::ExpandAll(const wxTreeItemId& item)
 {
 
 void wxGenericTreeCtrl::ExpandAll(const wxTreeItemId& item)
 {

-    Expand(item);
-    if ( IsExpanded(item) )
+    if ( !HasFlag(wxTR_HIDE_ROOT) || item != GetRootItem())

     {
     {

-        long cookie;
-        wxTreeItemId child = GetFirstChild(item, cookie);
-        while ( child.IsOk() )
-        {
-            ExpandAll(child);
+        Expand(item);
+        if ( !IsExpanded(item) )
+            return;
+    }

 
 

-            child = GetNextChild(item, cookie);
-        }
+    wxTreeItemIdValue cookie;
+    wxTreeItemId child = GetFirstChild(item, cookie);
+    while ( child.IsOk() )
+    {
+        ExpandAll(child);
+
+        child = GetNextChild(item, cookie);

     }
 }
 
 void wxGenericTreeCtrl::Collapse(const wxTreeItemId& itemId)
 {
     }
 }
 
 void wxGenericTreeCtrl::Collapse(const wxTreeItemId& itemId)
 {

+    wxCHECK_RET( !HasFlag(wxTR_HIDE_ROOT) || itemId != GetRootItem(),
+                 _T("can't collapse hidden root") );
+

     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
 
     if ( !item->IsExpanded() )
         return;
 
     wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_COLLAPSING, GetId() );
     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
 
     if ( !item->IsExpanded() )
         return;
 
     wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_COLLAPSING, GetId() );

-    event.m_item = (long) item;
+    event.m_item = item;

     event.SetEventObject( this );
     if ( ProcessEvent( event ) && !event.IsAllowed() )
     {
     event.SetEventObject( this );
     if ( ProcessEvent( event ) && !event.IsAllowed() )
     {


@@ -1291,14 +1667,17 @@ void wxGenericTreeCtrl::Collapse(const wxTreeItemId& itemId)
         return;
     }
 
         return;
     }
 

+    ChildrenClosing(item);

     item->Collapse();
 
     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]);
     }
     wxArrayGenericTreeItems& children = item->GetChildren();
     size_t count = children.Count();
     for ( size_t n = 0; n < count; n++ )
     {
         Collapse(children[n]);
     }

+#endif

 
     CalculatePositions();
 
 
     CalculatePositions();
 


@@ -1328,8 +1707,11 @@ 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;

     }
 }
 
     }
 }
 


@@ -1337,7 +1719,7 @@ void wxGenericTreeCtrl::UnselectAllChildren(wxGenericTreeItem *item)
 {
     if (item->IsSelected())
     {
 {
     if (item->IsSelected())
     {

-        item->SetHilight(FALSE);
+        item->SetHilight(false);

         RefreshLine(item);
     }
 
         RefreshLine(item);
     }
 


@@ -1354,7 +1736,13 @@ void wxGenericTreeCtrl::UnselectAllChildren(wxGenericTreeItem *item)
 
 void wxGenericTreeCtrl::UnselectAll()
 {
 
 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 !
 }
 
 // Recursive function !


@@ -1377,7 +1765,7 @@ bool wxGenericTreeCtrl::TagNextChildren(wxGenericTreeItem *crt_item, wxGenericTr
     size_t count = children.Count();
     for (size_t n=(size_t)(index+1); n<count; ++n)
     {
     size_t count = children.Count();
     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);


@@ -1389,7 +1777,7 @@ bool wxGenericTreeCtrl::TagAllChildrenUntilLast(wxGenericTreeItem *crt_item, wxG
     RefreshLine(crt_item);
 
     if (crt_item==last_item)
     RefreshLine(crt_item);
 
     if (crt_item==last_item)

-        return TRUE;
+        return true;

 
     if (crt_item->HasChildren())
     {
 
     if (crt_item->HasChildren())
     {


@@ -1398,29 +1786,21 @@ bool wxGenericTreeCtrl::TagAllChildrenUntilLast(wxGenericTreeItem *crt_item, wxG
         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();
 


@@ -1430,12 +1810,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;
 


@@ -1447,8 +1829,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() )
     {


@@ -1459,13 +1841,22 @@ void wxGenericTreeCtrl::SelectItem(const wxTreeItemId& itemId,
     }
 
     wxTreeEvent event( wxEVT_COMMAND_TREE_SEL_CHANGING, GetId() );
     }
 
     wxTreeEvent event( wxEVT_COMMAND_TREE_SEL_CHANGING, GetId() );

-    event.m_item = (long) item;
-    event.m_itemOld = (long) m_current;
+    event.m_item = item;
+    event.m_itemOld = m_current;

     event.SetEventObject( this );
     // TODO : Here we don't send any selection mode yet !
 
     if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() )
     event.SetEventObject( this );
     // TODO : Here we don't send any selection mode yet !
 
     if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() )

-      return;
+        return;
+
+    wxTreeItemId parent = GetItemParent( itemId );
+    while (parent.IsOk())
+    {
+        if (!IsExpanded(parent))
+            Expand( parent );
+
+        parent = GetItemParent( parent );
+    }

 
     // ctrl press
     if (unselect_others)
 
     // ctrl press
     if (unselect_others)


@@ -1479,8 +1870,7 @@ 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)


@@ -1488,23 +1878,44 @@ 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)

-          select=!item->IsSelected();
+            select=!item->IsSelected();

 
         m_current = m_key_current = item;
         m_current->SetHilight(select);
         RefreshLine( m_current );
     }
 
 
         m_current = m_key_current = item;
         m_current->SetHilight(select);
         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)
+{
+    if ( select )
+    {
+        DoSelectItem(itemId, !HasFlag(wxTR_MULTIPLE));
+    }
+    else // deselect
+    {
+        wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
+        wxCHECK_RET( item, wxT("SelectItem(): invalid tree item") );
+
+        item->SetHilight(false);
+        RefreshLine(item);
+    }
+}
+

 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));


@@ -1520,29 +1931,43 @@ void wxGenericTreeCtrl::FillArray(wxGenericTreeItem *item,
 
 size_t wxGenericTreeCtrl::GetSelections(wxArrayTreeItemIds &array) const
 {
 
 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)
 {
 }
 
 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();


@@ -1557,8 +1982,12 @@ 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.
     // 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
+        wxYieldIfNeeded();
+#endif

     wxGenericTreeItem *gitem = (wxGenericTreeItem*) item.m_pItem;
 
     // now scroll to the item
     wxGenericTreeItem *gitem = (wxGenericTreeItem*) item.m_pItem;
 
     // now scroll to the item


@@ -1566,7 +1995,7 @@ void wxGenericTreeCtrl::ScrollTo(const wxTreeItemId &item)
 
     int start_x = 0;
     int start_y = 0;
 
     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;
     start_y *= PIXELS_PER_UNIT;
 
     int client_h = 0;


@@ -1611,12 +2040,6 @@ static int LINKAGEMODE tree_ctrl_compare_func(wxGenericTreeItem **item1,
     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") );


@@ -1629,72 +2052,86 @@ void wxGenericTreeCtrl::SortChildren(const wxTreeItemId& itemId)
     wxArrayGenericTreeItems& children = item->GetChildren();
     if ( children.Count() > 1 )
     {
     wxArrayGenericTreeItems& children = item->GetChildren();
     if ( children.Count() > 1 )
     {

+        m_dirty = true;
+

         s_treeBeingSorted = this;
         children.Sort(tree_ctrl_compare_func);
         s_treeBeingSorted = NULL;
         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
 }
 
     }
     //else: don't make the tree dirty as nothing changed
 }
 

-wxImageList *wxGenericTreeCtrl::GetImageList() const
-{
-    return m_imageListNormal;
-}
-
-wxImageList *wxGenericTreeCtrl::GetStateImageList() const
-{
-    return m_imageListState;
-}
-
-void wxGenericTreeCtrl::SetImageList(wxImageList *imageList)
+void wxGenericTreeCtrl::CalculateLineHeight()

 {
 {

-    if (m_ownsImageListNormal) delete m_imageListNormal;
-
-    m_imageListNormal = imageList;
-    m_ownsImageListNormal = FALSE;
-
-    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);
     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 )
+    {
+        // 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)

     {
     {

-        m_imageListNormal->GetSize(i, width, height);
-        if (height > m_lineHeight) m_lineHeight = height;
+        // 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
 }
 
         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;
+    // 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;

 }
 
 }
 

-void wxGenericTreeCtrl::AssignImageList(wxImageList *imageList)
+void wxGenericTreeCtrl::SetButtonsImageList(wxImageList *imageList)

 {
 {

-    SetImageList(imageList);
-    m_ownsImageListNormal = TRUE;
+    if (m_ownsImageListButtons) delete m_imageListButtons;
+    m_imageListButtons = imageList;
+    m_ownsImageListButtons = false;
+    m_dirty = true;
+    CalculateLineHeight();

 }
 
 }
 

-void wxGenericTreeCtrl::AssignStateImageList(wxImageList *imageList)
+void wxGenericTreeCtrl::AssignButtonsImageList(wxImageList *imageList)

 {
 {

-    SetStateImageList(imageList);
-    m_ownsImageListState = TRUE;
+    SetButtonsImageList(imageList);
+    m_ownsImageListButtons = true;

 }
 
 // -----------------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------------


@@ -1705,8 +2142,7 @@ void wxGenericTreeCtrl::AdjustMyScrollbars()
 {
     if (m_anchor)
     {
 {
     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
         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


@@ -1730,25 +2166,25 @@ 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
+

     wxTreeItemAttr *attr = item->GetAttributes();
     if ( attr && attr->HasFont() )
         dc.SetFont(attr->GetFont());
     else if (item->IsBold())
         dc.SetFont(m_boldFont);
 
     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 );
 
     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 )
     {
         if ( m_imageListNormal )
         {
             m_imageListNormal->GetSize( image, image_w, image_h );
     int image = item->GetCurrentImage();
     if ( image != NO_IMAGE )
     {
         if ( m_imageListNormal )
         {
             m_imageListNormal->GetSize( image, image_w, image_h );

-            image_w += 4;
+            image_w += MARGIN_BETWEEN_IMAGE_AND_TEXT;

         }
         else
         {
         }
         else
         {


@@ -1757,20 +2193,70 @@ void wxGenericTreeCtrl::PaintItem(wxGenericTreeItem *item, wxDC& dc)
     }
 
     int total_h = GetLineHeight(item);
     }
 
     int total_h = GetLineHeight(item);

+    bool drawItemBackground = false;

 
 

-    if (item->IsSelected())
-        dc.SetBrush(*m_hilightBrush);
+    if ( item->IsSelected() )
+    {
+// under mac selections are only a rectangle in case they don't have the focus
+#ifdef __WXMAC__
+        if ( !m_hasFocus )
+        {
+            dc.SetBrush( *wxTRANSPARENT_BRUSH ) ;
+            dc.SetPen( wxPen( wxSystemSettings::GetColour( wxSYS_COLOUR_HIGHLIGHT ) , 1 , wxSOLID ) ) ;
+        }
+        else
+        {
+            dc.SetBrush( *m_hilightBrush ) ;
+        }
+#else
+        dc.SetBrush(*(m_hasFocus ? m_hilightBrush : m_hilightUnfocusedBrush));
+#endif
+        drawItemBackground = true;
+    }

     else
     {
         wxColour colBg;
         if ( attr && attr->HasBackgroundColour() )
     else
     {
         wxColour colBg;
         if ( attr && attr->HasBackgroundColour() )

+        {
+            drawItemBackground = true;

             colBg = attr->GetBackgroundColour();
             colBg = attr->GetBackgroundColour();

+        }

         else
         else

-            colBg = m_backgroundColour;
+        {
+            colBg = GetBackgroundColour();
+        }

         dc.SetBrush(wxBrush(colBg, wxSOLID));
     }
 
         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 );
+        }
+        // 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 );
+        }
+    }

 
     if ( image != NO_IMAGE )
     {
 
     if ( image != NO_IMAGE )
     {


@@ -1795,66 +2281,77 @@ 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 )
 {
 // 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);
-
-//        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 =
+#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;

 
 

-        wxPen *pen = wxTRANSPARENT_PEN;

         wxColour colText;
         wxColour colText;

-
-        if ( item->IsSelected() )
+        if ( item->IsSelected()
+#ifdef __WXMAC__
+            // 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
+#endif
+            )

         {
         {

-            colText = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_HIGHLIGHTTEXT );
-
-            if ( m_hasFocus )
-               pen = wxBLACK_PEN;
-
+            colText = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);

         }
         else
         {
             wxTreeItemAttr *attr = item->GetAttributes();
         }
         else
         {
             wxTreeItemAttr *attr = item->GetAttributes();

-            if ( attr && attr->HasTextColour() )
+            if (attr && attr->HasTextColour())

                 colText = attr->GetTextColour();
             else
                 colText = attr->GetTextColour();
             else

-                colText = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_WINDOWTEXT );
+                colText = GetForegroundColour();

         }
 
         // prepare to draw
         }
 
         // prepare to draw


@@ -1864,37 +2361,115 @@ void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level
         // draw
         PaintItem(item, dc);
 
         // draw
         PaintItem(item, dc);
 

-        // restore DC objects
-        dc.SetBrush( *wxWHITE_BRUSH );
-        dc.SetPen( m_dottedPen );
-        dc.SetTextForeground( *wxBLACK );
-    }
-
-    y = oldY+GetLineHeight(item);
+        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);
+        }

 
 

-    if (item->IsExpanded())
-    {
-        oldY+=GetLineHeight(item)/2;
-        int semiOldY=0;
+        // restore DC objects
+        dc.SetBrush(*wxWHITE_BRUSH);
+        dc.SetPen(m_dottedPen);
+        dc.SetTextForeground(*wxBLACK);

 
 

-        wxArrayGenericTreeItems& children = item->GetChildren();
-        size_t n, count = children.Count();
-        for ( n = 0; n < count; ++n )
+        if ( !HasFlag(wxTR_NO_LINES) )

         {
         {

-            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 (count > 0)
+        // should the item show a button?
+        if ( item->HasPlus() && HasButtons() )

         {
         {

-            semiOldY+=GetLineHeight(children[--n])/2;
-            if (drawLines)
-                dc.DrawLine( horizX+m_indent, oldY+5, horizX+m_indent, semiOldY );
-        }
-    }
+            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();
+        int count = children.Count();
+        if (count > 0)
+        {
+            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;
+
+                // 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 begining/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);
+            }
+        }
+    }

 }
 
 void wxGenericTreeCtrl::DrawDropEffect(wxGenericTreeItem *item)
 }
 
 void wxGenericTreeCtrl::DrawDropEffect(wxGenericTreeItem *item)


@@ -1910,7 +2485,7 @@ 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(wxCURSOR_BULLSEYE);


@@ -1960,7 +2535,7 @@ void wxGenericTreeCtrl::DrawLine(const wxTreeItemId &item, bool below)
 }
 
 // -----------------------------------------------------------------------------
 }
 
 // -----------------------------------------------------------------------------

-// wxWindows callbacks
+// wxWidgets callbacks

 // -----------------------------------------------------------------------------
 
 void wxGenericTreeCtrl::OnPaint( wxPaintEvent &WXUNUSED(event) )
 // -----------------------------------------------------------------------------
 
 void wxGenericTreeCtrl::OnPaint( wxPaintEvent &WXUNUSED(event) )


@@ -1982,26 +2557,34 @@ void wxGenericTreeCtrl::OnPaint( wxPaintEvent &WXUNUSED(event) )
     PaintLevel( m_anchor, dc, 0, y );
 }
 
     PaintLevel( m_anchor, dc, 0, y );
 }
 

-void wxGenericTreeCtrl::OnSetFocus( wxFocusEvent &WXUNUSED(event) )
+void wxGenericTreeCtrl::OnSetFocus( wxFocusEvent &event )

 {
 {

-    m_hasFocus = TRUE;
+    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;
+    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() );
 }
 
 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 );
     te.SetEventObject( this );

-    GetEventHandler()->ProcessEvent( te );
+    if ( GetEventHandler()->ProcessEvent( te ) )
+    {
+        // intercepted by the user code
+        return;
+    }

 
     if ( (m_current == 0) || (m_key_current == 0) )
     {
 
     if ( (m_current == 0) || (m_key_current == 0) )
     {


@@ -2013,7 +2596,7 @@ 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);
 
     // + : Expand
                         is_multiple, extended_select, unselect_others);
 
     // + : Expand


@@ -2026,7 +2609,9 @@ 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();
+    switch ( keyCode )

     {
         case '+':
         case WXK_ADD:
     {
         case '+':
         case WXK_ADD:


@@ -2054,35 +2639,61 @@ 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, GetId() );
+                eventMenu.m_item = m_current;
+                // Use the left edge, vertical middle
+                eventMenu.m_pointDrag = wxPoint(ItemRect.GetX(),
+                                                ItemRect.GetY() + ItemRect.GetHeight() / 2);
+                eventMenu.SetEventObject( this );
+                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.m_code = 0;
-                event.SetEventObject( this );
-                GetEventHandler()->ProcessEvent( event );
+                wxTreeEvent eventAct( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
+                eventAct.m_item = m_current;
+                eventAct.SetEventObject( this );
+                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;
 
             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)
                 {
         case WXK_UP:
             {
                 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)
                     {

-                        long cockie = 0;
+                        wxTreeItemIdValue cookie;

                         wxTreeItemId current = m_key_current;
                         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
                         {
                             // otherwise we return to where we came from

-                            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;
                         }
                     }


@@ -2098,9 +2709,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;


@@ -2108,18 +2718,22 @@ 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
+                    prev = GetPrevSibling( m_current );
+                }

                 if (prev)
                 {
                 if (prev)
                 {

-                    EnsureVisible( prev );
-                    SelectItem( prev, unselect_others, extended_select );
+                    DoSelectItem( prev, unselect_others, extended_select );

                 }
             }
             break;
 
         case WXK_RIGHT:
                 }
             }
             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
 
             Expand(m_current);
             // fall through
 


@@ -2127,11 +2741,10 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
             {
                 if (IsExpanded(m_key_current) && HasChildren(m_key_current))
                 {
             {
                 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 );
+                    DoSelectItem( child, unselect_others, extended_select );

                     m_key_current=(wxGenericTreeItem*) child.m_pItem;
                     m_key_current=(wxGenericTreeItem*) child.m_pItem;

-                    EnsureVisible( child );

                 }
                 else
                 {
                 }
                 else
                 {


@@ -2139,17 +2752,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 );

                     }
                 }
             }
                     }
                 }
             }


@@ -2166,7 +2778,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;
 


@@ -2175,8 +2787,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;


@@ -2185,156 +2796,264 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
         case WXK_HOME:
             {
                 wxTreeItemId prev = GetRootItem();
         case WXK_HOME:
             {
                 wxTreeItemId prev = GetRootItem();

-                if (prev)
+                if (!prev)
+                    break;
+
+                if ( HasFlag(wxTR_HIDE_ROOT) )

                 {
                 {

-                    EnsureVisible( prev );
-                    SelectItem( prev, unselect_others, extended_select );
+                    wxTreeItemIdValue cookie;
+                    prev = GetFirstChild(prev, cookie);
+                    if (!prev)
+                        break;

                 }
                 }

+
+                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)

 {
 {

-    // 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();
+    // 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);
     int w, h;
     GetSize(&w, &h);

-

     flags=0;
     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)
-        return m_anchor->HitTest( wxPoint(x, y), this, flags);
-    else
+    if (m_anchor == NULL)
+    {
+        flags = wxTREE_HITTEST_NOWHERE;

         return wxTreeItemId();
         return wxTreeItemId();

+    }
+
+    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,
 }
 
 // get the bounding rectangle of the item (or of its label only)
 bool wxGenericTreeCtrl::GetBoundingRect(const wxTreeItemId& item,

-                         wxRect& rect,
-                         bool textOnly) const
+                                        wxRect& rect,
+                                        bool textOnly) const

 {
 {

-    wxCHECK_MSG( item.IsOk(), FALSE, _T("invalid item in wxGenericTreeCtrl::GetBoundingRect") );
+    wxCHECK_MSG( item.IsOk(), false, _T("invalid item in wxGenericTreeCtrl::GetBoundingRect") );

 
     wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
 
     int startX, startY;
     GetViewStart(& startX, & startY);
 
 
     wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
 
     int startX, startY;
     GetViewStart(& startX, & startY);
 

-    rect.x = i->GetX() - startX*PIXELS_PER_UNIT;
-       rect.y = i->GetY() - startY*PIXELS_PER_UNIT;
-    rect.width = i->GetWidth();
-       //rect.height = i->GetHeight();
-       rect.height = GetLineHeight(i);
+    if ( textOnly )
+    {
+        rect.x = i->GetX() - startX*PIXELS_PER_UNIT;
+        rect.width = i->GetWidth();

 
 

-    return TRUE;
-}
+        if ( m_imageListNormal )
+        {
+            int image_w, image_h;
+            m_imageListNormal->GetSize( 0, image_w, image_h );
+            rect.width += image_w + MARGIN_BETWEEN_IMAGE_AND_TEXT;
+        }
+    }
+    else // the entire line
+    {
+        rect.x = 0;
+        rect.width = GetClientSize().x;
+    }

 
 

-/* **** */
+    rect.y = i->GetY() - startY*PIXELS_PER_UNIT;
+    rect.height = GetLineHeight(i);
+
+    return true;
+}

 
 

-void wxGenericTreeCtrl::Edit( const wxTreeItemId& item )
+wxTextCtrl *wxGenericTreeCtrl::EditLabel(const wxTreeItemId& item,
+                                  wxClassInfo * WXUNUSED(textCtrlClass))

 {
 {

-    if (!item.IsOk()) return;
+    wxCHECK_MSG( item.IsOk(), NULL, _T("can't edit an invalid item") );

 
 

-    m_currentEdit = (wxGenericTreeItem*) item.m_pItem;
+    wxGenericTreeItem *itemEdit = (wxGenericTreeItem *)item.m_pItem;

 
     wxTreeEvent te( wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, GetId() );
 
     wxTreeEvent te( wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, GetId() );

-    te.m_item = (long) m_currentEdit;
+    te.m_item = itemEdit;

     te.SetEventObject( this );
     te.SetEventObject( this );

-    GetEventHandler()->ProcessEvent( te );
-
-    if (!te.IsAllowed()) return;
+    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
+        wxYieldIfNeeded();
+#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 // !RightDown() && !LeftUp() ==> LeftDown() || LeftDClick()
-        {
-            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
-            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;
-            }
+    return m_textCtrl;
+}

 
 

+// 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;
+}

 
 

-    wxClientDC dc(this);
-    PrepareDC( dc );
-    x = dc.LogicalToDeviceX( x );
-    y = dc.LogicalToDeviceY( y );
+void wxGenericTreeCtrl::EndEditLabel(const wxTreeItemId& WXUNUSED(item),
+                                     bool discardChanges)
+{
+    wxCHECK_RET( m_textCtrl, _T("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, GetId() );
+    le.m_item = item;
+    le.SetEventObject( this );
+    le.m_label = value;
+    le.m_editCancelled = false;
+
+    return !GetEventHandler()->ProcessEvent( le ) || le.IsAllowed();

 }
 
 }
 

-void wxGenericTreeCtrl::OnRenameAccept()
+void wxGenericTreeCtrl::OnRenameCancelled(wxGenericTreeItem *item)

 {
 {

+    // let owner know that the edit was cancelled

     wxTreeEvent le( wxEVT_COMMAND_TREE_END_LABEL_EDIT, GetId() );
     wxTreeEvent le( wxEVT_COMMAND_TREE_END_LABEL_EDIT, GetId() );

-    le.m_item = (long) m_currentEdit;
+    le.m_item = item;

     le.SetEventObject( this );
     le.SetEventObject( this );

-    le.m_label = m_renameRes;
-    GetEventHandler()->ProcessEvent( le );
+    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 )
 {
     if ( !m_anchor ) return;
 
 }
 
 void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
 {
     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, GetId());
+        hevent.m_item = hoverItem;
+        hevent.SetEventObject(this);
+
+        if ( GetEventHandler()->ProcessEvent(hevent) && hevent.IsAllowed() )
+        {
+            SetToolTip(hevent.m_label);
+        }
+    }
+#endif
+

     // we process left mouse up event (enables in-place edit), right down
     // (pass to the user code), left dbl click (activate item) and
     // dragging/moving events for items drag-and-drop
     // we process left mouse up event (enables in-place edit), right down
     // (pass to the user code), left dbl click (activate item) and
     // dragging/moving events for items drag-and-drop


@@ -2350,18 +3069,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);
+    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++;
 


@@ -2376,8 +3091,9 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
                               : wxEVT_COMMAND_TREE_BEGIN_DRAG;
 
         wxTreeEvent nevent( command, GetId() );
                               : wxEVT_COMMAND_TREE_BEGIN_DRAG;
 
         wxTreeEvent nevent( command, GetId() );

-        nevent.m_item = (long) m_current;
+        nevent.m_item = m_current;

         nevent.SetEventObject(this);
         nevent.SetEventObject(this);

+        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


@@ -2386,7 +3102,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


@@ -2399,7 +3115,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);
                 }
             }


@@ -2407,7 +3123,7 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
             CaptureMouse();
         }
     }
             CaptureMouse();
         }
     }

-    else if ( event.Moving() )
+    else if ( event.Dragging() )

     {
         if ( item != m_dropTarget )
         {
     {
         if ( item != m_dropTarget )
         {


@@ -2419,7 +3135,11 @@ 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

             wxYieldIfNeeded();
             wxYieldIfNeeded();

+#endif

         }
     }
     else if ( (event.LeftUp() || event.RightUp()) && m_isDragging )
         }
     }
     else if ( (event.LeftUp() || event.RightUp()) && m_isDragging )


@@ -2427,33 +3147,47 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
         // erase the highlighting
         DrawDropEffect(m_dropTarget);
 
         // erase the highlighting
         DrawDropEffect(m_dropTarget);
 

-        // 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);
-
-        (void)GetEventHandler()->ProcessEvent(event);
-
-        m_isDragging = FALSE;
-        m_dropTarget = (wxGenericTreeItem *)NULL;
-

         if ( m_oldSelection )
         {
         if ( m_oldSelection )
         {

-            m_oldSelection->SetHilight(TRUE);
+            m_oldSelection->SetHilight(true);

             RefreshLine(m_oldSelection);
             m_oldSelection = (wxGenericTreeItem *)NULL;
         }
 
             RefreshLine(m_oldSelection);
             m_oldSelection = (wxGenericTreeItem *)NULL;
         }
 

+        // generate the drag end event
+        wxTreeEvent eventEndDrag(wxEVT_COMMAND_TREE_END_DRAG, GetId());
+
+        eventEndDrag.m_item = item;
+        eventEndDrag.m_pointDrag = CalcScrolledPosition(pt);
+        eventEndDrag.SetEventObject(this);
+
+        (void)GetEventHandler()->ProcessEvent(eventEndDrag);
+
+        m_isDragging = false;
+        m_dropTarget = (wxGenericTreeItem *)NULL;
+

         ReleaseMouse();
 
         SetCursor(m_oldCursor);
 
         ReleaseMouse();
 
         SetCursor(m_oldCursor);
 

+#if defined( __WXMSW__ ) || defined(__WXMAC__)
+        Update();
+#else

         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;


@@ -2462,76 +3196,158 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
 
         if ( event.RightDown() )
         {
 
         if ( event.RightDown() )
         {

+            // 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, GetId());
             wxTreeEvent nevent(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK, GetId());

-            nevent.m_item = (long) item;
-            nevent.m_code = 0;
-            CalcScrolledPosition(x, y,
-                                 &nevent.m_pointDrag.x,
-                                 &nevent.m_pointDrag.y);
+            nevent.m_item = item;
+            nevent.m_pointDrag = CalcScrolledPosition(pt);

             nevent.SetEventObject(this);
             nevent.SetEventObject(this);

-            GetEventHandler()->ProcessEvent(nevent);
+            event.Skip(!GetEventHandler()->ProcessEvent(nevent));
+
+            // Consistent with MSW (for now), send the ITEM_MENU *after*
+            // the RIGHT_CLICK event. TODO: This behavior may change.
+            wxTreeEvent nevent2(wxEVT_COMMAND_TREE_ITEM_MENU, GetId());
+            nevent2.m_item = item;
+            nevent2.m_pointDrag = CalcScrolledPosition(pt);
+            nevent2.SetEventObject(this);
+            GetEventHandler()->ProcessEvent(nevent2);

         }
         else if ( event.LeftUp() )
         {
         }
         else if ( event.LeftUp() )
         {

+            // 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
+        else // !RightDown() && !LeftUp() ==> LeftDown() || LeftDClick()

         {
             if ( event.LeftDown() )
             {
                 m_lastOnSame = item == m_current;
             }
 
         {
             if ( event.LeftDown() )
             {
                 m_lastOnSame = item == m_current;
             }
 

-            // 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);
+            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;
+            }

 
 

-            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
             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

                 wxTreeEvent nevent( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
                 wxTreeEvent nevent( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );

-                nevent.m_item = (long) item;
-                nevent.m_code = 0;
-                CalcScrolledPosition(x, y,
-                                     &nevent.m_pointDrag.x,
-                                     &nevent.m_pointDrag.y);
+                nevent.m_item = item;
+                nevent.m_pointDrag = CalcScrolledPosition(pt);

                 nevent.SetEventObject( this );
                 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);
+                    }
+                }

             }
         }
     }
 }
 
             }
         }
     }
 }
 

-void wxGenericTreeCtrl::OnIdle( wxIdleEvent &WXUNUSED(event) )
+void wxGenericTreeCtrl::OnInternalIdle()

 {
 {

+    wxWindow::OnInternalIdle();
+
+    // 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_select_me)
+            SelectItem(m_select_me);
+        else if (GetRootItem().IsOk())
+            SelectItem(GetRootItem());
+    }
+

     /* after all changes have been done to the tree control,
      * we actually redraw the tree when everything is over */
 
     /* 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;
+    if (m_freezeCount) return;

 
 

-    m_dirty = FALSE;
+    m_dirty = false;

 
     CalculatePositions();
     Refresh();
 
     CalculatePositions();
     Refresh();


@@ -2543,8 +3359,13 @@ void wxGenericTreeCtrl::CalculateSize( wxGenericTreeItem *item, wxDC &dc )
     wxCoord text_w = 0;
     wxCoord text_h = 0;
 
     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.SetFont(m_boldFont);

+    else
+        dc.SetFont(m_normalFont);

 
     dc.GetTextExtent( item->GetText(), &text_w, &text_h );
     text_h+=2;
 
     dc.GetTextExtent( item->GetText(), &text_w, &text_h );
     text_h+=2;


@@ -2560,13 +3381,13 @@ void wxGenericTreeCtrl::CalculateSize( wxGenericTreeItem *item, wxDC &dc )
         if ( m_imageListNormal )
         {
             m_imageListNormal->GetSize( image, image_w, image_h );
         if ( m_imageListNormal )
         {
             m_imageListNormal->GetSize( image, image_w, image_h );

-            image_w += 4;
+            image_w += MARGIN_BETWEEN_IMAGE_AND_TEXT;

         }
     }
 
     int total_h = (image_h > text_h) ? image_h : text_h;
 
         }
     }
 
     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
         total_h += 2;            // at least 2 pixels
     else
         total_h += total_h/10;   // otherwise 10% extra spacing


@@ -2583,25 +3404,37 @@ void wxGenericTreeCtrl::CalculateSize( wxGenericTreeItem *item, wxDC &dc )
 // not the middle of it !
 void wxGenericTreeCtrl::CalculateLevel( wxGenericTreeItem *item, wxDC &dc, int level, int &y )
 {
 // 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
 
     CalculateSize( item, dc );
 
     // set its position

-    item->SetX( horizX+m_indent+m_spacing );
+    item->SetX( x+m_spacing );

     item->SetY( y );
     item->SetY( y );

-    y+=GetLineHeight(item);
+    y += GetLineHeight(item);

 
     if ( !item->IsExpanded() )
     {
 
     if ( !item->IsExpanded() )
     {

-        // we dont need to calculate collapsed branches
+        // we don't need to calculate collapsed branches

         return;
     }
 
         return;
     }
 

+  Recurse:

     wxArrayGenericTreeItems& children = item->GetChildren();
     size_t n, count = children.Count();
     wxArrayGenericTreeItems& children = item->GetChildren();
     size_t n, count = children.Count();

+    ++level;

     for (n = 0; n < count; ++n )
     for (n = 0; n < count; ++n )

-        CalculateLevel( children[n], dc, level+1, y );  // recurse
+        CalculateLevel( children[n], dc, level, y );  // recurse

 }
 
 void wxGenericTreeCtrl::CalculatePositions()
 }
 
 void wxGenericTreeCtrl::CalculatePositions()


@@ -2624,21 +3457,16 @@ void wxGenericTreeCtrl::CalculatePositions()
 void wxGenericTreeCtrl::RefreshSubtree(wxGenericTreeItem *item)
 {
     if (m_dirty) return;
 void wxGenericTreeCtrl::RefreshSubtree(wxGenericTreeItem *item)
 {
     if (m_dirty) return;

+    if (m_freezeCount) return;

 
 

-    wxClientDC dc(this);
-    PrepareDC(dc);
-
-    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();
 }
 
     AdjustMyScrollbars();
 }


@@ -2646,20 +3474,132 @@ void wxGenericTreeCtrl::RefreshSubtree(wxGenericTreeItem *item)
 void wxGenericTreeCtrl::RefreshLine( wxGenericTreeItem *item )
 {
     if (m_dirty) return;
 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_freezeCount) 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()
+{
+    if (m_freezeCount) return;
+
+    // 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 (m_freezeCount) return;
+
+    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]);
+    }
+}
+
+void wxGenericTreeCtrl::Freeze()
+{
+    m_freezeCount++;
+}
+
+void wxGenericTreeCtrl::Thaw()
+{
+    wxCHECK_RET( m_freezeCount > 0, _T("thawing unfrozen tree control?") );
+
+    if ( !--m_freezeCount )
+    {
+        Refresh();
+    }
+}
+
+// ----------------------------------------------------------------------------
+// changing colours: we need to refresh the tree control
+// ----------------------------------------------------------------------------
+
+bool wxGenericTreeCtrl::SetBackgroundColour(const wxColour& colour)
+{
+    if ( !wxWindow::SetBackgroundColour(colour) )
+        return false;
+
+    if (m_freezeCount) return true;
+
+    Refresh();
+
+    return true;
+}
+
+bool wxGenericTreeCtrl::SetForegroundColour(const wxColour& colour)
+{
+    if ( !wxWindow::SetForegroundColour(colour) )
+        return false;
+
+    if (m_freezeCount) return true;
+
+    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
+
+#if _USE_VISATTR
+#include "wx/listbox.h"
+#endif
+
+//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_WINDOWTEXT);
+    attr.colBg = wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOX);
+    attr.font  = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
+    return attr;
+#endif
+}
+
+#if WXWIN_COMPATIBILITY_2_4
+
+int wxGenericTreeCtrl::GetItemSelectedImage(const wxTreeItemId& item) const
+{
+    return GetItemImage(item, wxTreeItemIcon_Selected);
+}
+
+void wxGenericTreeCtrl::SetItemSelectedImage(const wxTreeItemId& item, int image)
+{
+    SetItemImage(item, image, wxTreeItemIcon_Selected);
+}
+
+#endif // WXWIN_COMPATIBILITY_2_4
+
+#endif // wxUSE_TREECTRL