replace @b Note with @note; replace '' with "

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

diff --git a/src/generic/treectlg.cpp b/src/generic/treectlg.cpp
index 432f8f71d33c99f1e4ac58de0e8514fc56b74a05..2ac26238faca5042056fb78abe8b610e819a8172 100644 (file)
--- a/src/generic/treectlg.cpp
+++ b/src/generic/treectlg.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        treectlg.cpp
+// Name:        src/generic/treectlg.cpp

 // Purpose:     generic tree control implementation
 // Author:      Robert Roebling
 // Created:     01/02/97
 // Purpose:     generic tree control implementation
 // Author:      Robert Roebling
 // Created:     01/02/97


@@ -17,10 +17,6 @@
 // headers
 // -----------------------------------------------------------------------------
 
 // headers
 // -----------------------------------------------------------------------------
 

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-  #pragma implementation "treectlg.h"
-#endif
-

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


@@ -30,13 +26,18 @@
 
 #if wxUSE_TREECTRL
 
 
 #if wxUSE_TREECTRL
 

-#include "wx/treebase.h"
+#include "wx/treectrl.h"
+
+#ifndef WX_PRECOMP
+    #include "wx/dcclient.h"
+    #include "wx/timer.h"
+    #include "wx/settings.h"
+    #include "wx/listbox.h"
+    #include "wx/textctrl.h"
+#endif
+

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

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

 #include "wx/imaglist.h"
 #include "wx/imaglist.h"

-#include "wx/settings.h"
-#include "wx/dcclient.h"

 
 #include "wx/renderer.h"
 
 
 #include "wx/renderer.h"
 


@@ -48,9 +49,9 @@
 // array types
 // -----------------------------------------------------------------------------
 
 // array types
 // -----------------------------------------------------------------------------
 

-class WXDLLEXPORT wxGenericTreeItem;
+class WXDLLIMPEXP_FWD_CORE wxGenericTreeItem;

 
 

-WX_DEFINE_EXPORTED_ARRAY_PTR(wxGenericTreeItem *, wxArrayGenericTreeItems);
+WX_DEFINE_ARRAY_PTR(wxGenericTreeItem *, wxArrayGenericTreeItems);

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


@@ -60,6 +61,9 @@ static const int NO_IMAGE = -1;
 
 static const int 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
 // -----------------------------------------------------------------------------


@@ -88,11 +92,8 @@ class WXDLLEXPORT wxTreeTextCtrl: public wxTextCtrl
 public:
     wxTreeTextCtrl(wxGenericTreeCtrl *owner, wxGenericTreeItem *item);
 
 public:
     wxTreeTextCtrl(wxGenericTreeCtrl *owner, wxGenericTreeItem *item);
 

-    void StopEditing()
-    {
-        Finish();
-        m_owner->OnRenameCancelled(m_itemEdited);
-    }
+    void EndEdit( bool discardChanges );
+

     const wxGenericTreeItem* item() const { return m_itemEdited; }
 
 protected:
     const wxGenericTreeItem* item() const { return m_itemEdited; }
 
 protected:


@@ -101,13 +102,13 @@ protected:
     void OnKillFocus( wxFocusEvent &event );
 
     bool AcceptChanges();
     void OnKillFocus( wxFocusEvent &event );
 
     bool AcceptChanges();

-    void Finish();
+    void Finish( bool setfocus );

 
 private:
     wxGenericTreeCtrl  *m_owner;
     wxGenericTreeItem  *m_itemEdited;
     wxString            m_startValue;
 
 private:
     wxGenericTreeCtrl  *m_owner;
     wxGenericTreeItem  *m_itemEdited;
     wxString            m_startValue;

-    bool                m_finished;
+    bool                m_aboutToFinish;

 
     DECLARE_EVENT_TABLE()
     DECLARE_NO_COPY_CLASS(wxTreeTextCtrl)
 
     DECLARE_EVENT_TABLE()
     DECLARE_NO_COPY_CLASS(wxTreeTextCtrl)


@@ -180,9 +181,9 @@ public:
     wxGenericTreeItem *GetParent() const { return m_parent; }
 
     // operations
     wxGenericTreeItem *GetParent() const { return m_parent; }
 
     // operations

-        // deletes all children notifying the treectrl about it if !NULL
-        // pointer given
-    void DeleteChildren(wxGenericTreeCtrl *tree = NULL);
+
+    // deletes all children notifying the treectrl about it
+    void DeleteChildren(wxGenericTreeCtrl *tree);

 
     // get count of all children (and grand children if 'recursively')
     size_t GetChildrenCount(bool recursively = true) const;
 
     // get count of all children (and grand children if 'recursively')
     size_t GetChildrenCount(bool recursively = true) const;


@@ -262,12 +263,12 @@ private:
     int                 m_height;       // height of this item
 
     // use bitfields to save size
     int                 m_height;       // height of this item
 
     // use bitfields to save size

-    int                 m_isCollapsed :1;
-    int                 m_hasHilight  :1; // same as focused
-    int                 m_hasPlus     :1; // used for item which doesn't have
+    unsigned int        m_isCollapsed :1;
+    unsigned int        m_hasHilight  :1; // same as focused
+    unsigned int        m_hasPlus     :1; // used for item which doesn't have

                                           // children but has a [+] button
                                           // children but has a [+] button

-    int                 m_isBold      :1; // render the label in bold font
-    int                 m_ownsAttr    :1; // delete attribute when done
+    unsigned int        m_isBold      :1; // render the label in bold font
+    unsigned int        m_ownsAttr    :1; // delete attribute when done

 
     DECLARE_NO_COPY_CLASS(wxGenericTreeItem)
 };
 
     DECLARE_NO_COPY_CLASS(wxGenericTreeItem)
 };


@@ -340,7 +341,7 @@ wxTreeTextCtrl::wxTreeTextCtrl(wxGenericTreeCtrl *owner,
               : m_itemEdited(item), m_startValue(item->GetText())
 {
     m_owner = owner;
               : m_itemEdited(item), m_startValue(item->GetText())
 {
     m_owner = owner;

-    m_finished = false;
+    m_aboutToFinish = false;

 
     int w = m_itemEdited->GetWidth(),
         h = m_itemEdited->GetHeight();
 
     int w = m_itemEdited->GetWidth(),
         h = m_itemEdited->GetHeight();


@@ -357,7 +358,7 @@ wxTreeTextCtrl::wxTreeTextCtrl(wxGenericTreeCtrl *owner,
         if ( m_owner->m_imageListNormal )
         {
             m_owner->m_imageListNormal->GetSize( image, image_w, image_h );
         if ( m_owner->m_imageListNormal )
         {
             m_owner->m_imageListNormal->GetSize( image, image_w, image_h );

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

         }
         else
         {
         }
         else
         {


@@ -383,6 +384,26 @@ wxTreeTextCtrl::wxTreeTextCtrl(wxGenericTreeCtrl *owner,
                  wxPoint(x - 4, y - 4), wxSize(w + 11, h + 8));
 }
 
                  wxPoint(x - 4, y - 4), wxSize(w + 11, h + 8));
 }
 

+void wxTreeTextCtrl::EndEdit(bool discardChanges)
+{
+    m_aboutToFinish = true;
+
+    if ( discardChanges )
+    {
+        m_owner->OnRenameCancelled(m_itemEdited);
+
+        Finish( true );
+    }
+    else
+    {
+        // Notify the owner about the changes
+        AcceptChanges();
+
+        // Even if vetoed, close the control (consistent with MSW)
+        Finish( true );
+    }
+}
+

 bool wxTreeTextCtrl::AcceptChanges()
 {
     const wxString value = GetValue();
 bool wxTreeTextCtrl::AcceptChanges()
 {
     const wxString value = GetValue();


@@ -390,6 +411,12 @@ bool wxTreeTextCtrl::AcceptChanges()
     if ( value == m_startValue )
     {
         // nothing changed, always accept
     if ( value == m_startValue )
     {
         // nothing changed, always accept

+        // when an item remains unchanged, the owner
+        // needs to be notified that the user decided
+        // not to change the tree item label, and that
+        // the edit has been cancelled
+
+        m_owner->OnRenameCancelled(m_itemEdited);

         return true;
     }
 
         return true;
     }
 


@@ -405,18 +432,14 @@ bool wxTreeTextCtrl::AcceptChanges()
     return true;
 }
 
     return true;
 }
 

-void wxTreeTextCtrl::Finish()
+void wxTreeTextCtrl::Finish( bool setfocus )

 {
 {

-    if ( !m_finished )
-    {
-        m_owner->ResetTextControl();
-
-        wxPendingDelete.Append(this);
+    m_owner->ResetTextControl();

 
 

-        m_finished = true;
+    wxPendingDelete.Append(this);

 
 

-        m_owner->SetFocusIgnoringChildren();
-    }
+    if (setfocus)
+        m_owner->SetFocus();

 }
 
 void wxTreeTextCtrl::OnChar( wxKeyEvent &event )
 }
 
 void wxTreeTextCtrl::OnChar( wxKeyEvent &event )


@@ -424,16 +447,11 @@ void wxTreeTextCtrl::OnChar( wxKeyEvent &event )
     switch ( event.m_keyCode )
     {
         case WXK_RETURN:
     switch ( event.m_keyCode )
     {
         case WXK_RETURN:

-            if ( AcceptChanges() )
-            {
-                // Close the text control, changes were accepted
-                Finish();
-            }
-            // else do nothing, do not accept and do not close
+            EndEdit( false );

             break;
 
         case WXK_ESCAPE:
             break;
 
         case WXK_ESCAPE:

-            StopEditing();
+            EndEdit( true );

             break;
 
         default:
             break;
 
         default:


@@ -443,7 +461,7 @@ void wxTreeTextCtrl::OnChar( wxKeyEvent &event )
 
 void wxTreeTextCtrl::OnKeyUp( wxKeyEvent &event )
 {
 
 void wxTreeTextCtrl::OnKeyUp( wxKeyEvent &event )
 {

-    if ( !m_finished )
+    if ( !m_aboutToFinish )

     {
         // auto-grow the textctrl:
         wxSize parentSize = m_owner->GetSize();
     {
         // auto-grow the textctrl:
         wxSize parentSize = m_owner->GetSize();


@@ -463,16 +481,15 @@ void wxTreeTextCtrl::OnKeyUp( wxKeyEvent &event )
 
 void wxTreeTextCtrl::OnKillFocus( wxFocusEvent &event )
 {
 
 void wxTreeTextCtrl::OnKillFocus( wxFocusEvent &event )
 {

-    if ( !m_finished )
+    if ( !m_aboutToFinish )

     {
     {

-        AcceptChanges();
-        // We must finish regardless of success, otherwise we'll get
-        // focus problems:
-        Finish();
+        if ( !AcceptChanges() )
+            m_owner->OnRenameCancelled( m_itemEdited );
+
+        Finish( false );

     }
 
     }
 

-    // We must let the native text control handle focus, too, otherwise
-    // it could have problems with the cursor (e.g., in wxGTK):
+    // We should let the native text control handle focus, too.

     event.Skip();
 }
 
     event.Skip();
 }
 


@@ -521,15 +538,14 @@ wxGenericTreeItem::~wxGenericTreeItem()
 
 void wxGenericTreeItem::DeleteChildren(wxGenericTreeCtrl *tree)
 {
 
 void wxGenericTreeItem::DeleteChildren(wxGenericTreeCtrl *tree)
 {

-    size_t count = m_children.Count();
+    size_t count = m_children.GetCount();

     for ( size_t n = 0; n < count; n++ )
     {
         wxGenericTreeItem *child = m_children[n];
     for ( size_t n = 0; n < count; n++ )
     {
         wxGenericTreeItem *child = m_children[n];

-        if (tree)
-            tree->SendDeleteEvent(child);
+        tree->SendDeleteEvent(child);

 
         child->DeleteChildren(tree);
 
         child->DeleteChildren(tree);

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

             tree->m_select_me = NULL;
         delete child;
     }
             tree->m_select_me = NULL;
         delete child;
     }


@@ -544,7 +560,7 @@ void wxGenericTreeItem::SetText( const wxString &text )
 
 size_t wxGenericTreeItem::GetChildrenCount(bool recursively) const
 {
 
 size_t wxGenericTreeItem::GetChildrenCount(bool recursively) const
 {

-    size_t count = m_children.Count();
+    size_t count = m_children.GetCount();

     if ( !recursively )
         return count;
 
     if ( !recursively )
         return count;
 


@@ -567,7 +583,7 @@ void wxGenericTreeItem::GetSize( int &x, int &y,
 
     if (IsExpanded())
     {
 
     if (IsExpanded())
     {

-        size_t count = m_children.Count();
+        size_t count = m_children.GetCount();

         for ( size_t n = 0; n < count; ++n )
         {
             m_children[n]->GetSize( x, y, theButton );
         for ( size_t n = 0; n < count; ++n )
         {
             m_children[n]->GetSize( x, y, theButton );


@@ -642,7 +658,7 @@ wxGenericTreeItem *wxGenericTreeItem::HitTest(const wxPoint& point,
     }
 
     // evaluate children
     }
 
     // evaluate children

-    size_t count = m_children.Count();
+    size_t count = m_children.GetCount();

     for ( size_t n = 0; n < count; n++ )
     {
         wxGenericTreeItem *res = m_children[n]->HitTest( point,
     for ( size_t n = 0; n < count; n++ )
     {
         wxGenericTreeItem *res = m_children[n]->HitTest( point,


@@ -690,10 +706,11 @@ 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_PAINT          (wxGenericTreeCtrl::OnPaint)

+    EVT_SIZE           (wxGenericTreeCtrl::OnSize)

     EVT_MOUSE_EVENTS   (wxGenericTreeCtrl::OnMouse)
     EVT_CHAR           (wxGenericTreeCtrl::OnChar)
     EVT_SET_FOCUS      (wxGenericTreeCtrl::OnSetFocus)
     EVT_MOUSE_EVENTS   (wxGenericTreeCtrl::OnMouse)
     EVT_CHAR           (wxGenericTreeCtrl::OnChar)
     EVT_SET_FOCUS      (wxGenericTreeCtrl::OnSetFocus)


@@ -716,7 +733,10 @@ IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxGenericTreeCtrl)
 
 void wxGenericTreeCtrl::Init()
 {
 
 void wxGenericTreeCtrl::Init()
 {

-    m_current = m_key_current = m_anchor = m_select_me = (wxGenericTreeItem *) NULL;
+    m_current =
+    m_key_current =
+    m_anchor =
+    m_select_me = (wxGenericTreeItem *) NULL;

     m_hasFocus = false;
     m_dirty = false;
 
     m_hasFocus = false;
     m_dirty = false;
 


@@ -730,7 +750,7 @@ void wxGenericTreeCtrl::Init()
                             (
                                 wxSYS_COLOUR_HIGHLIGHT
                             ),
                             (
                                 wxSYS_COLOUR_HIGHLIGHT
                             ),

-                            wxSOLID
+                            wxBRUSHSTYLE_SOLID

                          );
 
     m_hilightUnfocusedBrush = new wxBrush
                          );
 
     m_hilightUnfocusedBrush = new wxBrush


@@ -739,13 +759,11 @@ void wxGenericTreeCtrl::Init()
                                  (
                                      wxSYS_COLOUR_BTNSHADOW
                                  ),
                                  (
                                      wxSYS_COLOUR_BTNSHADOW
                                  ),

-                                 wxSOLID
+                                 wxBRUSHSTYLE_SOLID

                               );
 
                               );
 

-    m_imageListNormal = m_imageListButtons =
-    m_imageListState = (wxImageList *) NULL;
-    m_ownsImageListNormal = m_ownsImageListButtons =
-    m_ownsImageListState = false;
+    m_imageListButtons = NULL;
+    m_ownsImageListButtons = false;

 
     m_dragCount = 0;
     m_isDragging = false;
 
     m_dragCount = 0;
     m_isDragging = false;


@@ -754,7 +772,6 @@ void wxGenericTreeCtrl::Init()
     m_textCtrl = NULL;
 
     m_renameTimer = NULL;
     m_textCtrl = NULL;
 
     m_renameTimer = NULL;

-    m_freezeCount = 0;

 
     m_findTimer = NULL;
 
 
     m_findTimer = NULL;
 


@@ -762,8 +779,8 @@ void wxGenericTreeCtrl::Init()
 
     m_lastOnSame = false;
 
 
     m_lastOnSame = false;
 

-#ifdef __WXMAC_CARBON__
-    m_normalFont.MacCreateThemeFont( kThemeViewsFont ) ;
+#ifdef __WXMAC__
+    m_normalFont.MacCreateFromThemeFont( kThemeViewsFont ) ;

 #else
     m_normalFont = wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT );
 #endif
 #else
     m_normalFont = wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT );
 #endif


@@ -781,21 +798,22 @@ bool wxGenericTreeCtrl::Create(wxWindow *parent,
                                const wxPoint& pos,
                                const wxSize& size,
                                long style,
                                const wxPoint& pos,
                                const wxSize& size,
                                long style,

-                               const wxValidator& wxVALIDATOR_PARAM(validator),
+                               const wxValidator& validator,

                                const wxString& name )
 {
 #ifdef __WXMAC__
                                const wxString& name )
 {
 #ifdef __WXMAC__

-    int major,minor;
-    wxGetOsVersion( &major, &minor );
+    int major, minor;
+    wxGetOsVersion(&major, &minor);

 
 

-    style &= ~wxTR_LINES_AT_ROOT;
-    style |= wxTR_NO_LINES;

     if (major < 10)
         style |= wxTR_ROW_LINES;
 #endif // __WXMAC__
 
     if (major < 10)
         style |= wxTR_ROW_LINES;
 #endif // __WXMAC__
 

-    wxScrolledWindow::Create( parent, id, pos, size,
-                              style|wxHSCROLL|wxVSCROLL, name );
+    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.
 
     // If the tree display has no buttons, but does have
     // connecting lines, we can use a narrower layout.


@@ -806,20 +824,22 @@ bool wxGenericTreeCtrl::Create(wxWindow *parent,
         m_spacing = 10;
     }
 
         m_spacing = 10;
     }
 

-#if wxUSE_VALIDATORS
-    SetValidator( validator );
-#endif
-

     wxVisualAttributes attr = GetDefaultAttributes();
     SetOwnForegroundColour( attr.colFg );
     SetOwnBackgroundColour( attr.colBg );
     if (!m_hasFont)
         SetOwnFont(attr.font);
 
     wxVisualAttributes attr = GetDefaultAttributes();
     SetOwnForegroundColour( attr.colFg );
     SetOwnBackgroundColour( attr.colBg );
     if (!m_hasFont)
         SetOwnFont(attr.font);
 

-//  m_dottedPen = wxPen( "grey", 0, wxDOT );  too slow under XFree86
-    m_dottedPen = wxPen( wxT("grey"), 0, 0 );
+    // this is a misnomer: it's called "dotted pen" but uses (default) wxSOLID
+    // style because we apparently get performance problems when using dotted
+    // pen for drawing in some ports -- but under MSW it seems to work fine
+#ifdef __WXMSW__
+    m_dottedPen = wxPen(*wxLIGHT_GREY, 0, wxPENSTYLE_DOT);
+#else
+    m_dottedPen = *wxGREY_PEN;
+#endif

 
 

-    SetBestSize(size);
+    SetInitialSize(size);

 
     return true;
 }
 
     return true;
 }


@@ -834,10 +854,6 @@ wxGenericTreeCtrl::~wxGenericTreeCtrl()
     delete m_renameTimer;
     delete m_findTimer;
 
     delete m_renameTimer;
     delete m_findTimer;
 

-    if (m_ownsImageListNormal)
-        delete m_imageListNormal;
-    if (m_ownsImageListState)
-        delete m_imageListState;

     if (m_ownsImageListButtons)
         delete m_imageListButtons;
 }
     if (m_ownsImageListButtons)
         delete m_imageListButtons;
 }


@@ -846,7 +862,7 @@ wxGenericTreeCtrl::~wxGenericTreeCtrl()
 // accessors
 // -----------------------------------------------------------------------------
 
 // accessors
 // -----------------------------------------------------------------------------
 

-size_t wxGenericTreeCtrl::GetCount() const
+unsigned int wxGenericTreeCtrl::GetCount() const

 {
     if ( !m_anchor )
     {
 {
     if ( !m_anchor )
     {


@@ -854,7 +870,7 @@ size_t wxGenericTreeCtrl::GetCount() const
         return 0;
     }
 
         return 0;
     }
 

-    size_t count = m_anchor->GetChildrenCount();
+    unsigned int count = m_anchor->GetChildrenCount();

     if ( !HasFlag(wxTR_HIDE_ROOT) )
     {
         // take the root itself into account
     if ( !HasFlag(wxTR_HIDE_ROOT) )
     {
         // take the root itself into account


@@ -870,12 +886,6 @@ void wxGenericTreeCtrl::SetIndent(unsigned int indent)
     m_dirty = true;
 }
 
     m_dirty = true;
 }
 

-void wxGenericTreeCtrl::SetSpacing(unsigned int spacing)
-{
-    m_spacing = (unsigned short) spacing;
-    m_dirty = true;
-}
-

 size_t
 wxGenericTreeCtrl::GetChildrenCount(const wxTreeItemId& item,
                                     bool recursively) const
 size_t
 wxGenericTreeCtrl::GetChildrenCount(const wxTreeItemId& item,
                                     bool recursively) const


@@ -887,7 +897,8 @@ wxGenericTreeCtrl::GetChildrenCount(const wxTreeItemId& item,
 
 void wxGenericTreeCtrl::SetWindowStyle(const long styles)
 {
 
 void wxGenericTreeCtrl::SetWindowStyle(const long styles)
 {

-    if (!HasFlag(wxTR_HIDE_ROOT) && (styles & wxTR_HIDE_ROOT))
+    // 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();
     {
         // if we will hide the root, make sure children are visible
         m_anchor->SetHasPlus();


@@ -908,7 +919,7 @@ void wxGenericTreeCtrl::SetWindowStyle(const long styles)
 
 wxString wxGenericTreeCtrl::GetItemText(const wxTreeItemId& item) const
 {
 
 wxString wxGenericTreeCtrl::GetItemText(const wxTreeItemId& item) const
 {

-    wxCHECK_MSG( item.IsOk(), wxT(""), wxT("invalid tree item") );
+    wxCHECK_MSG( item.IsOk(), wxEmptyString, wxT("invalid tree item") );

 
     return ((wxGenericTreeItem*) item.m_pItem)->GetText();
 }
 
     return ((wxGenericTreeItem*) item.m_pItem)->GetText();
 }


@@ -1005,10 +1016,35 @@ void wxGenericTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
     if ( pItem->IsBold() != bold )
     {
         pItem->SetBold(bold);
     if ( pItem->IsBold() != bold )
     {
         pItem->SetBold(bold);

+
+        // recalculate the item size as bold and non bold fonts have different
+        // widths
+        wxClientDC dc(this);
+        CalculateSize(pItem, dc);
+

         RefreshLine(pItem);
     }
 }
 
         RefreshLine(pItem);
     }
 }
 

+void wxGenericTreeCtrl::SetItemDropHighlight(const wxTreeItemId& item,
+                                             bool highlight)
+{
+    wxCHECK_RET( item.IsOk(), wxT("invalid tree item") );
+
+    wxColour fg, bg;
+
+    if (highlight)
+    {
+        bg = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
+        fg = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
+    }
+
+    wxGenericTreeItem *pItem = (wxGenericTreeItem*) item.m_pItem;
+    pItem->Attr().SetTextColour(fg);
+    pItem->Attr().SetBackgroundColour(bg);
+    RefreshLine(pItem);
+}
+

 void wxGenericTreeCtrl::SetItemTextColour(const wxTreeItemId& item,
                                    const wxColour& col)
 {
 void wxGenericTreeCtrl::SetItemTextColour(const wxTreeItemId& item,
                                    const wxColour& col)
 {


@@ -1040,7 +1076,7 @@ void wxGenericTreeCtrl::SetItemFont(const wxTreeItemId& item, const wxFont& font
 
 bool wxGenericTreeCtrl::SetFont( const wxFont &font )
 {
 
 bool wxGenericTreeCtrl::SetFont( const wxFont &font )
 {

-    wxScrolledWindow::SetFont(font);
+    wxTreeCtrlBase::SetFont(font);

 
     m_normalFont = font ;
     m_boldFont = wxFont(m_normalFont.GetPointSize(),
 
     m_normalFont = font ;
     m_boldFont = wxFont(m_normalFont.GetPointSize(),


@@ -1154,7 +1190,7 @@ wxTreeItemId wxGenericTreeCtrl::GetNextChild(const wxTreeItemId& item,
     // it's ok to cast cookie to size_t, we never have indices big enough to
     // overflow "void *"
     size_t *pIndex = (size_t *)&cookie;
     // 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() )
+    if ( *pIndex < children.GetCount() )

     {
         return children.Item((*pIndex)++);
     }
     {
         return children.Item((*pIndex)++);
     }


@@ -1165,36 +1201,6 @@ wxTreeItemId wxGenericTreeCtrl::GetNextChild(const wxTreeItemId& item,
     }
 }
 
     }
 }
 

-#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
 {
     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
 wxTreeItemId wxGenericTreeCtrl::GetLastChild(const wxTreeItemId& item) const
 {
     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );


@@ -1220,7 +1226,7 @@ wxTreeItemId wxGenericTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
     wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
 
     size_t n = (size_t)(index + 1);
     wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
 
     size_t n = (size_t)(index + 1);

-    return n == siblings.Count() ? wxTreeItemId() : wxTreeItemId(siblings[n]);
+    return n == siblings.GetCount() ? wxTreeItemId() : wxTreeItemId(siblings[n]);

 }
 
 wxTreeItemId wxGenericTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const
 }
 
 wxTreeItemId wxGenericTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const


@@ -1289,6 +1295,7 @@ wxTreeItemId wxGenericTreeCtrl::GetFirstVisibleItem() const
 wxTreeItemId wxGenericTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
 {
     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
 wxTreeItemId wxGenericTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
 {
     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );

+    wxASSERT_MSG( IsVisible(item), wxT("this item itself should be visible") );

 
     wxTreeItemId id = item;
     if (id.IsOk())
 
     wxTreeItemId id = item;
     if (id.IsOk())


@@ -1305,10 +1312,37 @@ wxTreeItemId wxGenericTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
 wxTreeItemId wxGenericTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
 {
     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );
 wxTreeItemId wxGenericTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
 {
     wxCHECK_MSG( item.IsOk(), wxTreeItemId(), wxT("invalid tree item") );

+    wxASSERT_MSG( IsVisible(item), wxT("this item itself should be visible") );

 
 

-    wxFAIL_MSG(wxT("not implemented"));
+    // find out the starting point
+    wxTreeItemId prevItem = GetPrevSibling(item);
+    if ( !prevItem.IsOk() )
+    {
+        prevItem = GetItemParent(item);
+    }

 
 

-    return wxTreeItemId();
+    // find the first visible item after it
+    while ( prevItem.IsOk() && !IsVisible(prevItem) )
+    {
+        prevItem = GetNext(prevItem);
+        if ( !prevItem.IsOk() || prevItem == item )
+        {
+            // there are no visible items before item
+            return wxTreeItemId();
+        }
+    }
+
+    // from there we must be able to navigate until this item
+    while ( prevItem.IsOk() )
+    {
+        const wxTreeItemId nextItem = GetNextVisible(prevItem);
+        if ( !nextItem.IsOk() || nextItem == item )
+            break;
+
+        prevItem = nextItem;
+    }
+
+    return prevItem;

 }
 
 // called by wxTextTreeCtrl when it marks itself for deletion
 }
 
 // called by wxTextTreeCtrl when it marks itself for deletion


@@ -1354,10 +1388,12 @@ wxTreeItemId wxGenericTreeCtrl::FindItem(const wxTreeItemId& idParent,
         }
 
         // and try all the items (stop when we get to the one we started from)
         }
 
         // and try all the items (stop when we get to the one we started from)

-        while ( id != idParent && !GetItemText(id).Lower().StartsWith(prefix) )
+        while (id.IsOk() && id != idParent && !GetItemText(id).Lower().StartsWith(prefix) )

         {
             id = GetNext(id);
         }
         {
             id = GetNext(id);
         }

+        // If we haven't found the item, id.IsOk() will be false, as per
+        // documentation

     }
 
     return id;
     }
 
     return id;


@@ -1368,10 +1404,11 @@ wxTreeItemId wxGenericTreeCtrl::FindItem(const wxTreeItemId& idParent,
 // -----------------------------------------------------------------------------
 
 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 )


@@ -1390,14 +1427,17 @@ wxTreeItemId wxGenericTreeCtrl::DoInsertItem(const wxTreeItemId& parentId,
         data->m_pItem = item;
     }
 
         data->m_pItem = item;
     }
 

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

 
 

+    InvalidateBestSize();

     return item;
 }
 
 wxTreeItemId wxGenericTreeCtrl::AddRoot(const wxString& text,
     return item;
 }
 
 wxTreeItemId wxGenericTreeCtrl::AddRoot(const wxString& text,

-                                 int image, int selImage,
-                                 wxTreeItemData *data)
+                                        int image,
+                                        int selImage,
+                                        wxTreeItemData *data)

 {
     wxCHECK_MSG( !m_anchor, wxTreeItemId(), wxT("tree can have only one root") );
 
 {
     wxCHECK_MSG( !m_anchor, wxTreeItemId(), wxT("tree can have only one root") );
 


@@ -1425,22 +1465,15 @@ wxTreeItemId wxGenericTreeCtrl::AddRoot(const wxString& text,
         m_current->SetHilight( true );
     }
 
         m_current->SetHilight( true );
     }
 

+    InvalidateBestSize();

     return m_anchor;
 }
 
     return m_anchor;
 }
 

-wxTreeItemId wxGenericTreeCtrl::PrependItem(const wxTreeItemId& parent,
-                                     const wxString& text,
-                                     int image, int selImage,
-                                     wxTreeItemData *data)
-{
-    return DoInsertItem(parent, 0u, text, image, selImage, data);
-}
-
-wxTreeItemId wxGenericTreeCtrl::InsertItem(const wxTreeItemId& parentId,
-                                    const wxTreeItemId& idPrevious,
-                                    const wxString& text,
-                                    int image, int selImage,
-                                    wxTreeItemData *data)
+wxTreeItemId wxGenericTreeCtrl::DoInsertAfter(const wxTreeItemId& parentId,
+                                              const wxTreeItemId& idPrevious,
+                                              const wxString& text,
+                                              int image, int selImage,
+                                              wxTreeItemData *data)

 {
     wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem;
     if ( !parent )
 {
     wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem;
     if ( !parent )


@@ -1460,51 +1493,18 @@ wxTreeItemId wxGenericTreeCtrl::InsertItem(const wxTreeItemId& parentId,
     return DoInsertItem(parentId, (size_t)++index, text, image, selImage, data);
 }
 
     return DoInsertItem(parentId, (size_t)++index, text, image, selImage, data);
 }
 

-wxTreeItemId wxGenericTreeCtrl::InsertItem(const wxTreeItemId& parentId,
-                                    size_t before,
-                                    const wxString& text,
-                                    int image, int selImage,
-                                    wxTreeItemData *data)
-{
-    wxGenericTreeItem *parent = (wxGenericTreeItem*) parentId.m_pItem;
-    if ( !parent )
-    {
-        // should we give a warning here?
-        return AddRoot(text, image, selImage, data);
-    }
-
-    return DoInsertItem(parentId, before, text, image, selImage, data);
-}
-
-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)
 {
 
 void wxGenericTreeCtrl::SendDeleteEvent(wxGenericTreeItem *item)
 {

-    wxTreeEvent event( wxEVT_COMMAND_TREE_DELETE_ITEM, GetId() );
-    event.m_item = item;
-    event.SetEventObject( this );
-    ProcessEvent( event );
+    wxTreeEvent event(wxEVT_COMMAND_TREE_DELETE_ITEM, this, item);
+    GetEventHandler()->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())) {
 }
 
 // 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();
+        m_textCtrl->EndEdit( true );

     }
     if (item != m_key_current && IsDescendantOf(item, m_key_current)) {
         m_key_current = NULL;
     }
     if (item != m_key_current && IsDescendantOf(item, m_key_current)) {
         m_key_current = NULL;


@@ -1526,6 +1526,7 @@ void wxGenericTreeCtrl::DeleteChildren(const wxTreeItemId& itemId)
     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
     ChildrenClosing(item);
     item->DeleteChildren(this);
     wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
     ChildrenClosing(item);
     item->DeleteChildren(this);

+    InvalidateBestSize();

 }
 
 void wxGenericTreeCtrl::Delete(const wxTreeItemId& itemId)
 }
 
 void wxGenericTreeCtrl::Delete(const wxTreeItemId& itemId)


@@ -1537,7 +1538,7 @@ void wxGenericTreeCtrl::Delete(const wxTreeItemId& itemId)
     if (m_textCtrl != NULL && IsDescendantOf(item, m_textCtrl->item()))
     {
         // can't delete the item being edited, cancel editing it first
     if (m_textCtrl != NULL && IsDescendantOf(item, m_textCtrl->item()))
     {
         // can't delete the item being edited, cancel editing it first

-        m_textCtrl->StopEditing();
+        m_textCtrl->EndEdit( true );

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


@@ -1590,6 +1591,8 @@ void wxGenericTreeCtrl::Delete(const wxTreeItemId& itemId)
         m_select_me = NULL;
 
     delete item;
         m_select_me = NULL;
 
     delete item;

+
+    InvalidateBestSize();

 }
 
 void wxGenericTreeCtrl::DeleteAllItems()
 }
 
 void wxGenericTreeCtrl::DeleteAllItems()


@@ -1614,42 +1617,28 @@ void wxGenericTreeCtrl::Expand(const wxTreeItemId& itemId)
     if ( item->IsExpanded() )
         return;
 
     if ( item->IsExpanded() )
         return;
 

-    wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_EXPANDING, GetId() );
-    event.m_item = item;
-    event.SetEventObject( this );
+    wxTreeEvent event(wxEVT_COMMAND_TREE_ITEM_EXPANDING, this, item);

 
 

-    if ( ProcessEvent( event ) && !event.IsAllowed() )
+    if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() )

     {
         // cancelled by program
         return;
     }
 
     item->Expand();
     {
         // cancelled by program
         return;
     }
 
     item->Expand();

-    CalculatePositions();
-
-    RefreshSubtree(item);
-
-    event.SetEventType(wxEVT_COMMAND_TREE_ITEM_EXPANDED);
-    ProcessEvent( event );
-}
-
-void wxGenericTreeCtrl::ExpandAll(const wxTreeItemId& item)
-{
-    if ( !HasFlag(wxTR_HIDE_ROOT) || item != GetRootItem())
+    if ( !IsFrozen() )

     {
     {

-        Expand(item);
-        if ( !IsExpanded(item) )
-            return;
-    }
+        CalculatePositions();

 
 

-    wxTreeItemIdValue cookie;
-    wxTreeItemId child = GetFirstChild(item, cookie);
-    while ( child.IsOk() )
+        RefreshSubtree(item);
+    }
+    else // frozen

     {
     {

-        ExpandAll(child);
-
-        child = GetNextChild(item, cookie);
+        m_dirty = true;

     }
     }

+
+    event.SetEventType(wxEVT_COMMAND_TREE_ITEM_EXPANDED);
+    GetEventHandler()->ProcessEvent( event );

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


@@ -1662,10 +1651,8 @@ void wxGenericTreeCtrl::Collapse(const wxTreeItemId& itemId)
     if ( !item->IsExpanded() )
         return;
 
     if ( !item->IsExpanded() )
         return;
 

-    wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_COLLAPSING, GetId() );
-    event.m_item = item;
-    event.SetEventObject( this );
-    if ( ProcessEvent( event ) && !event.IsAllowed() )
+    wxTreeEvent event(wxEVT_COMMAND_TREE_ITEM_COLLAPSING, this, item);
+    if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() )

     {
         // cancelled by program
         return;
     {
         // cancelled by program
         return;


@@ -1676,7 +1663,7 @@ void wxGenericTreeCtrl::Collapse(const wxTreeItemId& itemId)
 
 #if 0  // TODO why should items be collapsed recursively?
     wxArrayGenericTreeItems& children = item->GetChildren();
 
 #if 0  // TODO why should items be collapsed recursively?
     wxArrayGenericTreeItems& children = item->GetChildren();

-    size_t count = children.Count();
+    size_t count = children.GetCount();

     for ( size_t n = 0; n < count; n++ )
     {
         Collapse(children[n]);
     for ( size_t n = 0; n < count; n++ )
     {
         Collapse(children[n]);


@@ -1688,7 +1675,7 @@ void wxGenericTreeCtrl::Collapse(const wxTreeItemId& itemId)
     RefreshSubtree(item);
 
     event.SetEventType(wxEVT_COMMAND_TREE_ITEM_COLLAPSED);
     RefreshSubtree(item);
 
     event.SetEventType(wxEVT_COMMAND_TREE_ITEM_COLLAPSED);

-    ProcessEvent( event );
+    GetEventHandler()->ProcessEvent( event );

 }
 
 void wxGenericTreeCtrl::CollapseAndReset(const wxTreeItemId& item)
 }
 
 void wxGenericTreeCtrl::CollapseAndReset(const wxTreeItemId& item)


@@ -1730,7 +1717,7 @@ void wxGenericTreeCtrl::UnselectAllChildren(wxGenericTreeItem *item)
     if (item->HasChildren())
     {
         wxArrayGenericTreeItems& children = item->GetChildren();
     if (item->HasChildren())
     {
         wxArrayGenericTreeItems& children = item->GetChildren();

-        size_t count = children.Count();
+        size_t count = children.GetCount();

         for ( size_t n = 0; n < count; ++n )
         {
             UnselectAllChildren(children[n]);
         for ( size_t n = 0; n < count; ++n )
         {
             UnselectAllChildren(children[n]);


@@ -1766,7 +1753,7 @@ bool wxGenericTreeCtrl::TagNextChildren(wxGenericTreeItem *crt_item, wxGenericTr
     int index = children.Index(crt_item);
     wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
 
     int index = children.Index(crt_item);
     wxASSERT( index != wxNOT_FOUND ); // I'm not a child of my parent?
 

-    size_t count = children.Count();
+    size_t count = children.GetCount();

     for (size_t n=(size_t)(index+1); n<count; ++n)
     {
         if (TagAllChildrenUntilLast(children[n], last_item, select)) return true;
     for (size_t n=(size_t)(index+1); n<count; ++n)
     {
         if (TagAllChildrenUntilLast(children[n], last_item, select)) return true;


@@ -1786,7 +1773,7 @@ bool wxGenericTreeCtrl::TagAllChildrenUntilLast(wxGenericTreeItem *crt_item, wxG
     if (crt_item->HasChildren())
     {
         wxArrayGenericTreeItems& children = crt_item->GetChildren();
     if (crt_item->HasChildren())
     {
         wxArrayGenericTreeItems& children = crt_item->GetChildren();

-        size_t count = children.Count();
+        size_t count = children.GetCount();

         for ( size_t n = 0; n < count; ++n )
         {
             if (TagAllChildrenUntilLast(children[n], last_item, select))
         for ( size_t n = 0; n < count; ++n )
         {
             if (TagAllChildrenUntilLast(children[n], last_item, select))


@@ -1844,10 +1831,8 @@ void wxGenericTreeCtrl::DoSelectItem(const wxTreeItemId& itemId,
             return;
     }
 
             return;
     }
 

-    wxTreeEvent event( wxEVT_COMMAND_TREE_SEL_CHANGING, GetId() );
-    event.m_item = item;
+    wxTreeEvent event(wxEVT_COMMAND_TREE_SEL_CHANGING, this, item);

     event.m_itemOld = m_current;
     event.m_itemOld = m_current;

-    event.SetEventObject( this );

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


@@ -1862,8 +1847,6 @@ void wxGenericTreeCtrl::DoSelectItem(const wxTreeItemId& itemId,
         parent = GetItemParent( parent );
     }
 
         parent = GetItemParent( parent );
     }
 

-    EnsureVisible( itemId );
-

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


@@ -1895,6 +1878,11 @@ void wxGenericTreeCtrl::DoSelectItem(const wxTreeItemId& itemId,
         RefreshLine( m_current );
     }
 
         RefreshLine( m_current );
     }
 

+    // This can cause idle processing to select the root
+    // if no item is selected, so it must be after the
+    // selection is set
+    EnsureVisible( itemId );
+

     event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
     GetEventHandler()->ProcessEvent( event );
 }
     event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
     GetEventHandler()->ProcessEvent( event );
 }


@@ -1903,15 +1891,22 @@ void wxGenericTreeCtrl::SelectItem(const wxTreeItemId& itemId, bool select)
 {
     if ( select )
     {
 {
     if ( select )
     {

-        DoSelectItem(itemId);
+        DoSelectItem(itemId, !HasFlag(wxTR_MULTIPLE));

     }
     else // deselect
     {
         wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
         wxCHECK_RET( item, wxT("SelectItem(): invalid tree item") );
 
     }
     else // deselect
     {
         wxGenericTreeItem *item = (wxGenericTreeItem*) itemId.m_pItem;
         wxCHECK_RET( item, wxT("SelectItem(): invalid tree item") );
 

+        wxTreeEvent event(wxEVT_COMMAND_TREE_SEL_CHANGING, this, item);
+        if ( GetEventHandler()->ProcessEvent( event ) && !event.IsAllowed() )
+            return;
+

         item->SetHilight(false);
         RefreshLine(item);
         item->SetHilight(false);
         RefreshLine(item);

+
+        event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
+        GetEventHandler()->ProcessEvent( event );

     }
 }
 
     }
 }
 


@@ -1940,7 +1935,7 @@ size_t wxGenericTreeCtrl::GetSelections(wxArrayTreeItemIds &array) const
     }
     //else: the tree is empty, so no selections
 
     }
     //else: the tree is empty, so no selections
 

-    return array.Count();
+    return array.GetCount();

 }
 
 void wxGenericTreeCtrl::EnsureVisible(const wxTreeItemId& item)
 }
 
 void wxGenericTreeCtrl::EnsureVisible(const wxTreeItemId& item)


@@ -1987,7 +1982,7 @@ void wxGenericTreeCtrl::ScrollTo(const wxTreeItemId &item)
 #if defined( __WXMSW__ ) || defined(__WXMAC__)
         Update();
 #else
 #if defined( __WXMSW__ ) || defined(__WXMAC__)
         Update();
 #else

-        wxYieldIfNeeded();
+        DoDirtyProcessing();

 #endif
     wxGenericTreeItem *gitem = (wxGenericTreeItem*) item.m_pItem;
 
 #endif
     wxGenericTreeItem *gitem = (wxGenericTreeItem*) item.m_pItem;
 


@@ -2041,12 +2036,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") );


@@ -2057,7 +2046,7 @@ void wxGenericTreeCtrl::SortChildren(const wxTreeItemId& itemId)
                  wxT("wxGenericTreeCtrl::SortChildren is not reentrant") );
 
     wxArrayGenericTreeItems& children = item->GetChildren();
                  wxT("wxGenericTreeCtrl::SortChildren is not reentrant") );
 
     wxArrayGenericTreeItems& children = item->GetChildren();

-    if ( children.Count() > 1 )
+    if ( children.GetCount() > 1 )

     {
         m_dirty = true;
 
     {
         m_dirty = true;
 


@@ -2068,21 +2057,6 @@ void wxGenericTreeCtrl::SortChildren(const wxTreeItemId& itemId)
     //else: don't make the tree dirty as nothing changed
 }
 
     //else: don't make the tree dirty as nothing changed
 }
 

-wxImageList *wxGenericTreeCtrl::GetImageList() const
-{
-    return m_imageListNormal;
-}
-
-wxImageList *wxGenericTreeCtrl::GetButtonsImageList() const
-{
-    return m_imageListButtons;
-}
-
-wxImageList *wxGenericTreeCtrl::GetStateImageList() const
-{
-    return m_imageListState;
-}
-

 void wxGenericTreeCtrl::CalculateLineHeight()
 {
     wxClientDC dc(this);
 void wxGenericTreeCtrl::CalculateLineHeight()
 {
     wxClientDC dc(this);


@@ -2150,18 +2124,6 @@ void wxGenericTreeCtrl::SetButtonsImageList(wxImageList *imageList)
     CalculateLineHeight();
 }
 
     CalculateLineHeight();
 }
 

-void wxGenericTreeCtrl::AssignImageList(wxImageList *imageList)
-{
-    SetImageList(imageList);
-    m_ownsImageListNormal = true;
-}
-
-void wxGenericTreeCtrl::AssignStateImageList(wxImageList *imageList)
-{
-    SetStateImageList(imageList);
-    m_ownsImageListState = true;
-}
-

 void wxGenericTreeCtrl::AssignButtonsImageList(wxImageList *imageList)
 {
     SetButtonsImageList(imageList);
 void wxGenericTreeCtrl::AssignButtonsImageList(wxImageList *imageList)
 {
     SetButtonsImageList(imageList);


@@ -2208,7 +2170,7 @@ void wxGenericTreeCtrl::PaintItem(wxGenericTreeItem *item, wxDC& dc)
     else if (item->IsBold())
         dc.SetFont(m_boldFont);
 
     else if (item->IsBold())
         dc.SetFont(m_boldFont);
 

-    long text_w = 0, text_h = 0;
+    wxCoord text_w = 0, text_h = 0;

     dc.GetTextExtent( item->GetText(), &text_w, &text_h );
 
     int image_h = 0, image_w = 0;
     dc.GetTextExtent( item->GetText(), &text_w, &text_h );
 
     int image_h = 0, image_w = 0;


@@ -2218,7 +2180,7 @@ void wxGenericTreeCtrl::PaintItem(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;

         }
         else
         {
         }
         else
         {


@@ -2227,43 +2189,57 @@ void wxGenericTreeCtrl::PaintItem(wxGenericTreeItem *item, wxDC& dc)
     }
 
     int total_h = GetLineHeight(item);
     }
 
     int total_h = GetLineHeight(item);

+    bool drawItemBackground = false;

 
     if ( item->IsSelected() )
     {
 
     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));
         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;
-        dc.SetBrush(wxBrush(colBg, wxSOLID));
+        {
+            colBg = GetBackgroundColour();
+        }
+        dc.SetBrush(wxBrush(colBg, wxBRUSHSTYLE_SOLID));

     }
 
     int offset = HasFlag(wxTR_ROW_LINES) ? 1 : 0;
 
     if ( HasFlag(wxTR_FULL_ROW_HIGHLIGHT) )
     {
     }
 
     int offset = HasFlag(wxTR_ROW_LINES) ? 1 : 0;
 
     if ( HasFlag(wxTR_FULL_ROW_HIGHLIGHT) )
     {

-        int x, y, w, h;
-
-        DoGetPosition(&x, &y);
-        DoGetSize(&w, &h);
-        dc.DrawRectangle(x, item->GetY()+offset, w, total_h-offset);
+        int x, w, h;
+        x=0;
+        GetVirtualSize(&w, &h);
+        wxRect rect( x, item->GetY()+offset, w, total_h-offset);
+#if !defined(__WXGTK20__) && !defined(__WXMAC__)
+        dc.DrawRectangle(rect);
+#else
+        if (!item->IsSelected())
+        {
+            dc.DrawRectangle(rect);
+        }
+        else
+        {
+            int flags = wxCONTROL_SELECTED;
+            if (m_hasFocus
+#if defined( __WXMAC__ ) && !defined(__WXUNIVERSAL__)
+                && IsControlActive( (ControlRef)GetHandle() )
+#endif
+            )
+                flags |= wxCONTROL_FOCUSED;
+            if ((item == m_current) && (m_hasFocus))
+                flags |= wxCONTROL_CURRENT;
+            wxRendererNative::Get().DrawItemSelectionRect( this, dc, rect, flags );
+        }
+#endif

     }
     else
     {
     }
     else
     {


@@ -2272,13 +2248,49 @@ void wxGenericTreeCtrl::PaintItem(wxGenericTreeItem *item, wxDC& dc)
             // 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.
             // 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 );
+            wxRect rect( item->GetX() + image_w - 2, item->GetY()+offset,
+                         item->GetWidth() - image_w + 2, total_h-offset );
+#if !defined(__WXGTK20__) && !defined(__WXMAC__)
+            dc.DrawRectangle( rect );
+#else
+            rect.x -= 1;
+            rect.width += 2;
+
+            int flags = wxCONTROL_SELECTED;
+            if (m_hasFocus)
+                flags |= wxCONTROL_FOCUSED;
+            if ((item == m_current) && (m_hasFocus))
+                flags |= wxCONTROL_CURRENT;
+            wxRendererNative::Get().DrawItemSelectionRect( this, dc, rect, flags );
+#endif

         }
         }

-        else
+        // On GTK+ 2, drawing a 'normal' background is wrong for themes that
+        // don't allow backgrounds to be customized. Not drawing the background,
+        // except for custom item backgrounds, works for both kinds of theme.
+        else if (drawItemBackground)

         {
         {

-            dc.DrawRectangle( item->GetX()-2, item->GetY()+offset,
-                              item->GetWidth()+2, total_h-offset );
+            wxRect rect( item->GetX()-2, item->GetY()+offset,
+                         item->GetWidth()+2, total_h-offset );
+#if !defined(__WXGTK20__) && !defined(__WXMAC__)
+            dc.DrawRectangle( rect );
+#else
+            if ( attr && attr->HasBackgroundColour() )
+            {
+                dc.DrawRectangle( rect );
+            }
+            else
+            {
+                rect.x -= 1;
+                rect.width += 2;
+
+                int flags = wxCONTROL_SELECTED;
+                if (m_hasFocus)
+                    flags |= wxCONTROL_FOCUSED;
+                if ((item == m_current) && (m_hasFocus))
+                    flags |= wxCONTROL_CURRENT;
+                wxRendererNative::Get().DrawItemSelectionRect( this, dc, rect, flags );
+            }
+#endif

         }
     }
 
         }
     }
 


@@ -2292,7 +2304,7 @@ void wxGenericTreeCtrl::PaintItem(wxGenericTreeItem *item, wxDC& dc)
         dc.DestroyClippingRegion();
     }
 
         dc.DestroyClippingRegion();
     }
 

-    dc.SetBackgroundMode(wxTRANSPARENT);
+    dc.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);

     int extraH = (total_h > text_h) ? (total_h - text_h)/2 : 0;
     dc.DrawText( item->GetText(),
                  (wxCoord)(image_w + item->GetX()),
     int extraH = (total_h > text_h) ? (total_h - text_h)/2 : 0;
     dc.DrawText( item->GetText(),
                  (wxCoord)(image_w + item->GetX()),


@@ -2315,7 +2327,7 @@ void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level
         // always expand hidden root
         int origY = y;
         wxArrayGenericTreeItems& children = item->GetChildren();
         // always expand hidden root
         int origY = y;
         wxArrayGenericTreeItems& children = item->GetChildren();

-        int count = children.Count();
+        int count = children.GetCount();

         if (count > 0)
         {
             int n = 0, oldY;
         if (count > 0)
         {
             int n = 0, oldY;


@@ -2348,7 +2360,7 @@ void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level
 
     if (IsExposed(exposed_x, exposed_y, 10000, h))  // 10000 = very much
     {
 
     if (IsExposed(exposed_x, exposed_y, 10000, h))  // 10000 = very much
     {

-        wxPen *pen =
+        const wxPen *pen =

 #ifndef __WXMAC__
             // don't draw rect outline if we already have the
             // background color under Mac
 #ifndef __WXMAC__
             // don't draw rect outline if we already have the
             // background color under Mac


@@ -2357,9 +2369,21 @@ void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level
             wxTRANSPARENT_PEN;
 
         wxColour colText;
             wxTRANSPARENT_PEN;
 
         wxColour colText;

-        if ( item->IsSelected() )
+        if ( item->IsSelected()
+#if defined( __WXMAC__ ) && !defined(__WXUNIVERSAL__)
+            // On wxMac, if the tree doesn't have the focus we draw an empty
+            // rectangle, so we want to make sure that the text is visible
+            // against the normal background, not the highlightbackground, so
+            // don't use the highlight text colour unless we have the focus.
+             && m_hasFocus && IsControlActive( (ControlRef)GetHandle() )
+#endif
+            )

         {
         {

+#ifdef __WXMAC__
+            colText = *wxWHITE;
+#else

             colText = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
             colText = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);

+#endif

         }
         else
         {
         }
         else
         {


@@ -2451,7 +2475,7 @@ void wxGenericTreeCtrl::PaintLevel( wxGenericTreeItem *item, wxDC &dc, int level
     if (item->IsExpanded())
     {
         wxArrayGenericTreeItems& children = item->GetChildren();
     if (item->IsExpanded())
     {
         wxArrayGenericTreeItems& children = item->GetChildren();

-        int count = children.Count();
+        int count = children.GetCount();

         if (count > 0)
         {
             int n = 0, oldY;
         if (count > 0)
         {
             int n = 0, oldY;


@@ -2554,6 +2578,16 @@ void wxGenericTreeCtrl::DrawLine(const wxTreeItemId &item, bool below)
 // wxWidgets callbacks
 // -----------------------------------------------------------------------------
 
 // wxWidgets callbacks
 // -----------------------------------------------------------------------------
 

+void wxGenericTreeCtrl::OnSize( wxSizeEvent &event )
+{
+#ifdef __WXGTK__
+    if (HasFlag( wxTR_FULL_ROW_HIGHLIGHT) && m_current)
+        RefreshLine( m_current );
+#endif
+
+    event.Skip(true);
+}
+

 void wxGenericTreeCtrl::OnPaint( wxPaintEvent &WXUNUSED(event) )
 {
     wxPaintDC dc(this);
 void wxGenericTreeCtrl::OnPaint( wxPaintEvent &WXUNUSED(event) )
 {
     wxPaintDC dc(this);


@@ -2593,9 +2627,8 @@ void wxGenericTreeCtrl::OnKillFocus( wxFocusEvent &event )
 
 void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
 {
 
 void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
 {

-    wxTreeEvent te( wxEVT_COMMAND_TREE_KEY_DOWN, GetId() );
+    wxTreeEvent te( wxEVT_COMMAND_TREE_KEY_DOWN, this);

     te.m_evtKey = event;
     te.m_evtKey = event;

-    te.SetEventObject( this );

     if ( GetEventHandler()->ProcessEvent( te ) )
     {
         // intercepted by the user code
     if ( GetEventHandler()->ProcessEvent( te ) )
     {
         // intercepted by the user code


@@ -2612,9 +2645,17 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
     bool is_multiple, extended_select, unselect_others;
     EventFlagsToSelType(GetWindowStyleFlag(),
                         event.ShiftDown(),
     bool is_multiple, extended_select, unselect_others;
     EventFlagsToSelType(GetWindowStyleFlag(),
                         event.ShiftDown(),

-                        event.ControlDown(),
+                        event.CmdDown(),

                         is_multiple, extended_select, unselect_others);
 
                         is_multiple, extended_select, unselect_others);
 

+    if (GetLayoutDirection() == wxLayout_RightToLeft)
+    {
+        if (event.GetKeyCode() == WXK_RIGHT)
+            event.m_keyCode = WXK_LEFT;
+        else if (event.GetKeyCode() == WXK_LEFT)
+            event.m_keyCode = WXK_RIGHT;
+    }
+

     // + : Expand
     // - : Collaspe
     // * : Expand all/Collapse all
     // + : Expand
     // - : Collaspe
     // * : Expand all/Collapse all


@@ -2642,7 +2683,7 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
             if ( !IsExpanded(m_current) )
             {
                 // expand all
             if ( !IsExpanded(m_current) )
             {
                 // expand all

-                ExpandAll(m_current);
+                ExpandAllChildren(m_current);

                 break;
             }
             //else: fall through to Collapse() it
                 break;
             }
             //else: fall through to Collapse() it


@@ -2657,20 +2698,24 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
 
         case WXK_MENU:
             {
 
         case WXK_MENU:
             {

-                wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_MENU, GetId() );
-                event.m_item = m_current;
-                event.SetEventObject( this );
-                GetEventHandler()->ProcessEvent( event );
-                break;
+                // Use the item's bounding rectangle to determine position for the event
+                wxRect ItemRect;
+                GetBoundingRect(m_current, ItemRect, true);
+
+                wxTreeEvent eventMenu(wxEVT_COMMAND_TREE_ITEM_MENU, this, m_current);
+                // Use the left edge, vertical middle
+                eventMenu.m_pointDrag = wxPoint(ItemRect.GetX(),
+                                                ItemRect.GetY() + ItemRect.GetHeight() / 2);
+                GetEventHandler()->ProcessEvent( eventMenu );

             }
             }

+            break;
+

         case ' ':
         case WXK_RETURN:
             if ( !event.HasModifiers() )
             {
         case ' ':
         case WXK_RETURN:
             if ( !event.HasModifiers() )
             {

-                wxTreeEvent event( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
-                event.m_item = m_current;
-                event.SetEventObject( this );
-                GetEventHandler()->ProcessEvent( event );
+                wxTreeEvent eventAct(wxEVT_COMMAND_TREE_ITEM_ACTIVATED, this, m_current);
+                GetEventHandler()->ProcessEvent( eventAct );

             }
 
             // in any case, also generate the normal key event for this key,
             }
 
             // in any case, also generate the normal key event for this key,


@@ -2743,7 +2788,11 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
         case WXK_RIGHT:
             // this works the same as the down arrow except that we
             // also expand the item if it wasn't expanded yet
         case WXK_RIGHT:
             // this works the same as the down arrow except that we
             // also expand the item if it wasn't expanded yet

-            Expand(m_current);
+            if (m_current != GetRootItem().m_pItem || !HasFlag(wxTR_HIDE_ROOT))
+                Expand(m_current);
+            //else: don't try to expand hidden root item (which can be the
+            //      current one when the tree is empty)
+

             // fall through
 
         case WXK_DOWN:
             // fall through
 
         case WXK_DOWN:


@@ -2752,6 +2801,9 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
                 {
                     wxTreeItemIdValue cookie;
                     wxTreeItemId child = GetFirstChild( m_key_current, cookie );
                 {
                     wxTreeItemIdValue cookie;
                     wxTreeItemId child = GetFirstChild( m_key_current, cookie );

+                    if ( !child )
+                        break;
+

                     DoSelectItem( child, unselect_others, extended_select );
                     m_key_current=(wxGenericTreeItem*) child.m_pItem;
                 }
                     DoSelectItem( child, unselect_others, extended_select );
                     m_key_current=(wxGenericTreeItem*) child.m_pItem;
                 }


@@ -2858,11 +2910,9 @@ void wxGenericTreeCtrl::OnChar( wxKeyEvent &event )
     }
 }
 
     }
 }
 

-wxTreeItemId wxGenericTreeCtrl::HitTest(const wxPoint& point, int& flags)
+wxTreeItemId
+wxGenericTreeCtrl::DoTreeHitTest(const wxPoint& point, int& flags) const

 {
 {

-    // JACS: removed wxYieldIfNeeded() because it can cause the window
-    // to be deleted from under us if a close window event is pending
-

     int w, h;
     GetSize(&w, &h);
     flags=0;
     int w, h;
     GetSize(&w, &h);
     flags=0;


@@ -2891,37 +2941,51 @@ wxTreeItemId wxGenericTreeCtrl::HitTest(const wxPoint& point, int& flags)
 // get the bounding rectangle of the item (or of its label only)
 bool wxGenericTreeCtrl::GetBoundingRect(const wxTreeItemId& item,
                                         wxRect& rect,
 // get the bounding rectangle of the item (or of its label only)
 bool wxGenericTreeCtrl::GetBoundingRect(const wxTreeItemId& item,
                                         wxRect& rect,

-                                        bool WXUNUSED(textOnly)) const
+                                        bool textOnly) const

 {
     wxCHECK_MSG( item.IsOk(), false, _T("invalid item in wxGenericTreeCtrl::GetBoundingRect") );
 
     wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
 
 {
     wxCHECK_MSG( item.IsOk(), false, _T("invalid item in wxGenericTreeCtrl::GetBoundingRect") );
 
     wxGenericTreeItem *i = (wxGenericTreeItem*) item.m_pItem;
 

-    int startX, startY;
-    GetViewStart(& startX, & startY);
+    if ( textOnly )
+    {
+        rect.x = i->GetX();
+        rect.width = i->GetWidth();
+
+        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.x = i->GetX() - startX*PIXELS_PER_UNIT;
-    rect.y = i->GetY() - startY*PIXELS_PER_UNIT;
-    rect.width = i->GetWidth();
-    //rect.height = i->GetHeight();
+    rect.y = i->GetY();

     rect.height = GetLineHeight(i);
 
     rect.height = GetLineHeight(i);
 

+    // we have to return the logical coordinates, not physical ones
+    rect.SetTopLeft(CalcScrolledPosition(rect.GetTopLeft()));
+

     return true;
 }
 
     return true;
 }
 

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

 {
 {

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

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

-    wxTreeEvent te( wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, GetId() );
-    te.m_item = itemEdit;
-    te.SetEventObject( this );
+    wxTreeEvent te(wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, this, itemEdit);

     if ( GetEventHandler()->ProcessEvent( te ) && !te.IsAllowed() )
     {
         // vetoed by user
     if ( GetEventHandler()->ProcessEvent( te ) && !te.IsAllowed() )
     {
         // vetoed by user

-        return;
+        return NULL;

     }
 
     // We have to call this here because the label in
     }
 
     // We have to call this here because the label in


@@ -2931,12 +2995,15 @@ void wxGenericTreeCtrl::Edit( const wxTreeItemId& item )
 #if defined( __WXMSW__ ) || defined(__WXMAC__)
         Update();
 #else
 #if defined( __WXMSW__ ) || defined(__WXMAC__)
         Update();
 #else

-        wxYieldIfNeeded();
+        DoDirtyProcessing();

 #endif
 
 #endif
 

+    // TODO: use textCtrlClass here to create the control of correct class

     m_textCtrl = new wxTreeTextCtrl(this, itemEdit);
 
     m_textCtrl->SetFocus();
     m_textCtrl = new wxTreeTextCtrl(this, itemEdit);
 
     m_textCtrl->SetFocus();

+
+    return m_textCtrl;

 }
 
 // returns a pointer to the text edit control if the item is being
 }
 
 // returns a pointer to the text edit control if the item is being


@@ -2947,12 +3014,18 @@ wxTextCtrl* wxGenericTreeCtrl::GetEditControl() const
     return m_textCtrl;
 }
 
     return m_textCtrl;
 }
 

+void wxGenericTreeCtrl::EndEditLabel(const wxTreeItemId& WXUNUSED(item),
+                                     bool discardChanges)
+{
+    wxCHECK_RET( m_textCtrl, _T("not editing label") );
+
+    m_textCtrl->EndEdit(discardChanges);
+}
+

 bool wxGenericTreeCtrl::OnRenameAccept(wxGenericTreeItem *item,
                                        const wxString& value)
 {
 bool wxGenericTreeCtrl::OnRenameAccept(wxGenericTreeItem *item,
                                        const wxString& value)
 {

-    wxTreeEvent le( wxEVT_COMMAND_TREE_END_LABEL_EDIT, GetId() );
-    le.m_item = item;
-    le.SetEventObject( this );
+    wxTreeEvent le(wxEVT_COMMAND_TREE_END_LABEL_EDIT, this, item);

     le.m_label = value;
     le.m_editCancelled = false;
 
     le.m_label = value;
     le.m_editCancelled = false;
 


@@ -2962,9 +3035,7 @@ bool wxGenericTreeCtrl::OnRenameAccept(wxGenericTreeItem *item,
 void wxGenericTreeCtrl::OnRenameCancelled(wxGenericTreeItem *item)
 {
     // let owner know that the edit was cancelled
 void wxGenericTreeCtrl::OnRenameCancelled(wxGenericTreeItem *item)
 {
     // let owner know that the edit was cancelled

-    wxTreeEvent le( wxEVT_COMMAND_TREE_END_LABEL_EDIT, GetId() );
-    le.m_item = item;
-    le.SetEventObject( this );
+    wxTreeEvent le(wxEVT_COMMAND_TREE_END_LABEL_EDIT, this, item);

     le.m_label = wxEmptyString;
     le.m_editCancelled = true;
 
     le.m_label = wxEmptyString;
     le.m_editCancelled = true;
 


@@ -2973,12 +3044,12 @@ void wxGenericTreeCtrl::OnRenameCancelled(wxGenericTreeItem *item)
 
 void wxGenericTreeCtrl::OnRenameTimer()
 {
 
 void wxGenericTreeCtrl::OnRenameTimer()
 {

-    Edit( m_current );
+    EditLabel( m_current );

 }
 
 void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
 {
 }
 
 void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
 {

-    if ( !m_anchor ) return;
+    if ( !m_anchor )return;

 
     wxPoint pt = CalcUnscrolledPosition(event.GetPosition());
 
 
     wxPoint pt = CalcUnscrolledPosition(event.GetPosition());
 


@@ -3025,9 +3096,7 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
     if (underMouseChanged && hoverItem.IsOk() && !m_isDragging && (!m_renameTimer || !m_renameTimer->IsRunning()))
     {
         // Ask the tree control what tooltip (if any) should be shown
     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);
+        wxTreeEvent hevent(wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP,  this, hoverItem);

 
         if ( GetEventHandler()->ProcessEvent(hevent) && hevent.IsAllowed() )
         {
 
         if ( GetEventHandler()->ProcessEvent(hevent) && hevent.IsAllowed() )
         {


@@ -3036,11 +3105,12 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
     }
 #endif
 
     }
 #endif
 

-    // we process left mouse up event (enables in-place edit), right down
+    // we process left mouse up event (enables in-place edit), middle/right down

     // (pass to the user code), left dbl click (activate item) and
     // dragging/moving events for items drag-and-drop
     if ( !(event.LeftDown() ||
            event.LeftUp() ||
     // (pass to the user code), left dbl click (activate item) and
     // dragging/moving events for items drag-and-drop
     if ( !(event.LeftDown() ||
            event.LeftUp() ||

+           event.MiddleDown() ||

            event.RightDown() ||
            event.LeftDClick() ||
            event.Dragging() ||
            event.RightDown() ||
            event.LeftDClick() ||
            event.Dragging() ||


@@ -3072,9 +3142,8 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
                               ? wxEVT_COMMAND_TREE_BEGIN_RDRAG
                               : wxEVT_COMMAND_TREE_BEGIN_DRAG;
 
                               ? wxEVT_COMMAND_TREE_BEGIN_RDRAG
                               : wxEVT_COMMAND_TREE_BEGIN_DRAG;
 

-        wxTreeEvent nevent( command, GetId() );
-        nevent.m_item = m_current;
-        nevent.SetEventObject(this);
+        wxTreeEvent nevent(command,  this, m_current);
+        nevent.SetPoint(CalcScrolledPosition(pt));

 
         // by default the dragging is not supported, the user code must
         // explicitly allow the event for it to take place
 
         // by default the dragging is not supported, the user code must
         // explicitly allow the event for it to take place


@@ -3125,6 +3194,8 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
     }
     else if ( (event.LeftUp() || event.RightUp()) && m_isDragging )
     {
     }
     else if ( (event.LeftUp() || event.RightUp()) && m_isDragging )
     {

+        ReleaseMouse();
+

         // erase the highlighting
         DrawDropEffect(m_dropTarget);
 
         // erase the highlighting
         DrawDropEffect(m_dropTarget);
 


@@ -3136,19 +3207,15 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
         }
 
         // generate the drag end event
         }
 
         // generate the drag end event

-        wxTreeEvent event(wxEVT_COMMAND_TREE_END_DRAG, GetId());
+        wxTreeEvent eventEndDrag(wxEVT_COMMAND_TREE_END_DRAG,  this, item);

 
 

-        event.m_item = item;
-        event.m_pointDrag = pt;
-        event.SetEventObject(this);
+        eventEndDrag.m_pointDrag = CalcScrolledPosition(pt);

 
 

-        (void)GetEventHandler()->ProcessEvent(event);
+        (void)GetEventHandler()->ProcessEvent(eventEndDrag);

 
         m_isDragging = false;
         m_dropTarget = (wxGenericTreeItem *)NULL;
 
 
         m_isDragging = false;
         m_dropTarget = (wxGenericTreeItem *)NULL;
 

-        ReleaseMouse();
-

         SetCursor(m_oldCursor);
 
 #if defined( __WXMSW__ ) || defined(__WXMAC__)
         SetCursor(m_oldCursor);
 
 #if defined( __WXMSW__ ) || defined(__WXMAC__)


@@ -3177,23 +3244,40 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
 
         if ( event.RightDown() )
         {
 
         if ( event.RightDown() )
         {

-            wxTreeEvent nevent(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK, GetId());
-            nevent.m_item = item;
+            // If the item is already selected, do not update the selection.
+            // Multi-selections should not be cleared if a selected item is clicked.
+            if (!IsSelected(item))
+            {
+                DoSelectItem(item, true, false);
+            }
+
+            wxTreeEvent nevent(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK,  this, item);
+            nevent.m_pointDrag = CalcScrolledPosition(pt);
+            event.Skip(!GetEventHandler()->ProcessEvent(nevent));
+
+            // Consistent with MSW (for now), send the ITEM_MENU *after*
+            // the RIGHT_CLICK event. TODO: This behavior may change.
+            wxTreeEvent nevent2(wxEVT_COMMAND_TREE_ITEM_MENU,  this, item);
+            nevent2.m_pointDrag = CalcScrolledPosition(pt);
+            GetEventHandler()->ProcessEvent(nevent2);
+        }
+        else if ( event.MiddleDown() )
+        {
+            wxTreeEvent nevent(wxEVT_COMMAND_TREE_ITEM_MIDDLE_CLICK,  this, item);

             nevent.m_pointDrag = CalcScrolledPosition(pt);
             nevent.m_pointDrag = CalcScrolledPosition(pt);

-            nevent.SetEventObject(this);
-            GetEventHandler()->ProcessEvent(nevent);
+            event.Skip(!GetEventHandler()->ProcessEvent(nevent));

         }
         else if ( event.LeftUp() )
         {
             // this facilitates multiple-item drag-and-drop
 
         }
         else if ( event.LeftUp() )
         {
             // this facilitates multiple-item drag-and-drop
 

-            if (item && HasFlag(wxTR_MULTIPLE))
+            if ( /* item && */ HasFlag(wxTR_MULTIPLE))

             {
                 wxArrayTreeItemIds selections;
                 size_t count = GetSelections(selections);
 
                 if (count > 1 &&
             {
                 wxArrayTreeItemIds selections;
                 size_t count = GetSelections(selections);
 
                 if (count > 1 &&

-                    !event.ControlDown() &&
+                    !event.CmdDown() &&

                     !event.ShiftDown())
                 {
                     DoSelectItem(item, true, false);
                     !event.ShiftDown())
                 {
                     DoSelectItem(item, true, false);


@@ -3222,7 +3306,7 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
                 m_lastOnSame = false;
             }
         }
                 m_lastOnSame = false;
             }
         }

-        else // !RightDown() && !LeftUp() ==> LeftDown() || LeftDClick()
+        else // !RightDown() && !MiddleDown() && !LeftUp() ==> LeftDown() || LeftDClick()

         {
             if ( event.LeftDown() )
             {
         {
             if ( event.LeftDown() )
             {


@@ -3247,14 +3331,14 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
             // user clicked outside of the present selection.
             // otherwise, perform the deselection on mouse-up.
             // this allows multiple drag and drop to work.
             // user clicked outside of the present selection.
             // otherwise, perform the deselection on mouse-up.
             // this allows multiple drag and drop to work.

-
-            if (!IsSelected(item))
+            // 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(),
             {
                 // how should the selection work for this event?
                 bool is_multiple, extended_select, unselect_others;
                 EventFlagsToSelType(GetWindowStyleFlag(),
                                     event.ShiftDown(),

-                                    event.ControlDown(),
+                                    event.CmdDown(),

                                     is_multiple, extended_select, unselect_others);
 
                 DoSelectItem(item, unselect_others, extended_select);
                                     is_multiple, extended_select, unselect_others);
 
                 DoSelectItem(item, unselect_others, extended_select);


@@ -3272,10 +3356,8 @@ void wxGenericTreeCtrl::OnMouse( wxMouseEvent &event )
                 m_lastOnSame = false;
 
                 // send activate event first
                 m_lastOnSame = false;
 
                 // send activate event first

-                wxTreeEvent nevent( wxEVT_COMMAND_TREE_ITEM_ACTIVATED, GetId() );
-                nevent.m_item = item;
+                wxTreeEvent nevent(wxEVT_COMMAND_TREE_ITEM_ACTIVATED,  this, item);

                 nevent.m_pointDrag = CalcScrolledPosition(pt);
                 nevent.m_pointDrag = CalcScrolledPosition(pt);

-                nevent.SetEventObject( this );

                 if ( !GetEventHandler()->ProcessEvent( nevent ) )
                 {
                     // if the user code didn't process the activate event,
                 if ( !GetEventHandler()->ProcessEvent( nevent ) )
                 {
                     // if the user code didn't process the activate event,


@@ -3307,17 +3389,10 @@ void wxGenericTreeCtrl::OnInternalIdle()
             SelectItem(GetRootItem());
     }
 
             SelectItem(GetRootItem());
     }
 

-    /* 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_freezeCount) return;
-
-    m_dirty = false;
-
-    CalculatePositions();
-    Refresh();
-    AdjustMyScrollbars();
+    // after all changes have been done to the tree control,
+    // actually redraw the tree when everything is over
+    if (m_dirty)
+        DoDirtyProcessing();

 }
 
 void wxGenericTreeCtrl::CalculateSize( wxGenericTreeItem *item, wxDC &dc )
 }
 
 void wxGenericTreeCtrl::CalculateSize( wxGenericTreeItem *item, wxDC &dc )


@@ -3347,7 +3422,7 @@ 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;

         }
     }
 
         }
     }
 


@@ -3397,7 +3472,7 @@ void wxGenericTreeCtrl::CalculateLevel( wxGenericTreeItem *item, wxDC &dc, int l
 
   Recurse:
     wxArrayGenericTreeItems& children = item->GetChildren();
 
   Recurse:
     wxArrayGenericTreeItems& children = item->GetChildren();

-    size_t n, count = children.Count();
+    size_t n, count = children.GetCount();

     ++level;
     for (n = 0; n < count; ++n )
         CalculateLevel( children[n], dc, level, y );  // recurse
     ++level;
     for (n = 0; n < count; ++n )
         CalculateLevel( children[n], dc, level, y );  // recurse


@@ -3420,10 +3495,16 @@ void wxGenericTreeCtrl::CalculatePositions()
     CalculateLevel( m_anchor, dc, 0, y ); // start recursion
 }
 
     CalculateLevel( m_anchor, dc, 0, y ); // start recursion
 }
 

+void wxGenericTreeCtrl::Refresh(bool eraseBackground, const wxRect *rect)
+{
+    if ( !IsFrozen() )
+        wxTreeCtrlBase::Refresh(eraseBackground, rect);
+}
+

 void wxGenericTreeCtrl::RefreshSubtree(wxGenericTreeItem *item)
 {
 void wxGenericTreeCtrl::RefreshSubtree(wxGenericTreeItem *item)
 {

-    if (m_dirty) return;
-    if (m_freezeCount) return;
+    if (m_dirty || IsFrozen() )
+        return;

 
     wxSize client = GetClientSize();
 
 
     wxSize client = GetClientSize();
 


@@ -3439,8 +3520,8 @@ void wxGenericTreeCtrl::RefreshSubtree(wxGenericTreeItem *item)
 
 void wxGenericTreeCtrl::RefreshLine( wxGenericTreeItem *item )
 {
 
 void wxGenericTreeCtrl::RefreshLine( wxGenericTreeItem *item )
 {

-    if (m_dirty) return;
-    if (m_freezeCount) return;
+    if (m_dirty || IsFrozen() )
+        return;

 
     wxRect rect;
     CalcScrolledPosition(0, item->GetY(), NULL, &rect.y);
 
     wxRect rect;
     CalcScrolledPosition(0, item->GetY(), NULL, &rect.y);


@@ -3452,7 +3533,8 @@ void wxGenericTreeCtrl::RefreshLine( wxGenericTreeItem *item )
 
 void wxGenericTreeCtrl::RefreshSelected()
 {
 
 void wxGenericTreeCtrl::RefreshSelected()
 {

-    if (m_freezeCount) return;
+    if (IsFrozen())
+        return;

 
     // TODO: this is awfully inefficient, we should keep the list of all
     //       selected items internally, should be much faster
 
     // TODO: this is awfully inefficient, we should keep the list of all
     //       selected items internally, should be much faster


@@ -3462,7 +3544,8 @@ void wxGenericTreeCtrl::RefreshSelected()
 
 void wxGenericTreeCtrl::RefreshSelectedUnder(wxGenericTreeItem *item)
 {
 
 void wxGenericTreeCtrl::RefreshSelectedUnder(wxGenericTreeItem *item)
 {

-    if (m_freezeCount) return;
+    if (IsFrozen())
+        return;

 
     if ( item->IsSelected() )
         RefreshLine(item);
 
     if ( item->IsSelected() )
         RefreshLine(item);


@@ -3475,19 +3558,14 @@ void wxGenericTreeCtrl::RefreshSelectedUnder(wxGenericTreeItem *item)
     }
 }
 
     }
 }
 

-void wxGenericTreeCtrl::Freeze()
+void wxGenericTreeCtrl::DoThaw()

 {
 {

-    m_freezeCount++;
-}
+    wxTreeCtrlBase::DoThaw();

 
 

-void wxGenericTreeCtrl::Thaw()
-{
-    wxCHECK_RET( m_freezeCount > 0, _T("thawing unfrozen tree control?") );
-
-    if ( !--m_freezeCount )
-    {
+    if ( m_dirty )
+        DoDirtyProcessing();
+    else

         Refresh();
         Refresh();

-    }

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


@@ -3499,8 +3577,6 @@ bool wxGenericTreeCtrl::SetBackgroundColour(const wxColour& colour)
     if ( !wxWindow::SetBackgroundColour(colour) )
         return false;
 
     if ( !wxWindow::SetBackgroundColour(colour) )
         return false;
 

-    if (m_freezeCount) return true;
-

     Refresh();
 
     return true;
     Refresh();
 
     return true;


@@ -3511,8 +3587,6 @@ bool wxGenericTreeCtrl::SetForegroundColour(const wxColour& colour)
     if ( !wxWindow::SetForegroundColour(colour) )
         return false;
 
     if ( !wxWindow::SetForegroundColour(colour) )
         return false;
 

-    if (m_freezeCount) return true;
-

     Refresh();
 
     return true;
     Refresh();
 
     return true;


@@ -3526,23 +3600,10 @@ void wxGenericTreeCtrl::OnGetToolTip( wxTreeEvent &event )
 }
 
 
 }
 
 

-wxSize wxGenericTreeCtrl::DoGetBestSize() const
-{
-    // something is better than nothing...
-    // 100x80 is what the MSW version will get from the default
-    // wxControl::DoGetBestSize
-    return wxSize(100,80);
-}
-
-

 // 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
 
 // 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
 //static
 wxVisualAttributes
 #if _USE_VISATTR


@@ -3563,27 +3624,47 @@ wxGenericTreeCtrl::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
 #endif
 }
 
 #endif
 }
 

-#if WXWIN_COMPATIBILITY_2_4
-
-int wxGenericTreeCtrl::GetItemSelectedImage(const wxTreeItemId& item) const
+void wxGenericTreeCtrl::DoDirtyProcessing()

 {
 {

-    return GetItemImage(item, wxTreeItemIcon_Selected);
+    if (IsFrozen())
+        return;
+
+    m_dirty = false;
+
+    CalculatePositions();
+    Refresh();
+    AdjustMyScrollbars();

 }
 
 }
 

-void wxGenericTreeCtrl::SetItemSelectedImage(const wxTreeItemId& item, int image)
+wxSize wxGenericTreeCtrl::DoGetBestSize() const

 {
 {

-    SetItemImage(item, image, wxTreeItemIcon_Selected);
-}
+    // make sure all positions are calculated as normally this only done during
+    // idle time but we need them for base class DoGetBestSize() to return the
+    // correct result
+    wxConstCast(this, wxGenericTreeCtrl)->CalculatePositions();

 
 

-#endif // WXWIN_COMPATIBILITY_2_4
+    wxSize size = wxTreeCtrlBase::DoGetBestSize();

 
 

-#if WXWIN_COMPATIBILITY_2_2
+    // there seems to be an implicit extra border around the items, although
+    // I'm not really sure where does it come from -- but without this, the
+    // scrollbars appear in a tree with default/best size
+    size.IncBy(4, 4);

 
 

-wxTreeItemId wxGenericTreeCtrl::GetParent(const wxTreeItemId& item) const
-{
-    return GetItemParent( item );
-}
+    // and the border has to be rounded up to a multiple of PIXELS_PER_UNIT or
+    // scrollbars still appear
+    const wxSize& borderSize = GetWindowBorderSize();
+
+    int dx = (size.x - borderSize.x) % PIXELS_PER_UNIT;
+    if ( dx )
+        size.x += PIXELS_PER_UNIT - dx;
+    int dy = (size.y - borderSize.y) % PIXELS_PER_UNIT;
+    if ( dy )
+        size.y += PIXELS_PER_UNIT - dy;

 
 

-#endif  // WXWIN_COMPATIBILITY_2_2
+    // we need to update the cache too as the base class cached its own value
+    CacheBestSize(size);
+
+    return size;
+}

 
 #endif // wxUSE_TREECTRL
 
 #endif // wxUSE_TREECTRL