some typos in docs and code corrected (thanks Janos)

[wxWidgets.git] / src / msw / treectrl.cpp

diff --git a/src/msw/treectrl.cpp b/src/msw/treectrl.cpp
index 98cd3568a12497c77fb76f1d00f77ce9275caf7d..eb6dfc49774a897eaf883c1253c905ccc3225502 100644 (file)
--- a/src/msw/treectrl.cpp
+++ b/src/msw/treectrl.cpp
@@ -28,22 +28,41 @@
 #endif
 
 #ifndef WX_PRECOMP
 #endif
 
 #ifndef WX_PRECOMP

-    #include "wx.h"
+    #include "wx/wx.h"

 #endif
 
 #if defined(__WIN95__)
 
 #include "wx/log.h"
 #endif
 
 #if defined(__WIN95__)
 
 #include "wx/log.h"

+#include "wx/dynarray.h"

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

+#include "wx/msw/treectrl.h"

 
 #include "wx/msw/private.h"
 
 
 #include "wx/msw/private.h"
 

-#ifndef __GNUWIN32__
+#ifdef __GNUWIN32__
+#include "wx/msw/gnuwin32/extra.h"
+#endif
+
+#if (defined(__WIN95__) && !defined(__GNUWIN32__)) || defined(__TWIN32__)

     #include <commctrl.h>
 #endif
 
     #include <commctrl.h>
 #endif
 

-#define  wxHTREEITEM_DEFINED    // flag used in wx/msw/treectrl.h
-#include "wx/treectrl.h"
+#ifdef GetFirstChild
+#undef GetFirstChild
+#endif
+
+#ifdef GetNextChild
+#undef GetNextChild
+#endif
+
+#ifdef GetNextSibling
+#undef GetNextSibling
+#endif
+
+#ifdef GetClassInfo
+#undef GetClassInfo
+#endif

 
 // Bug in headers, sometimes
 #ifndef TVIS_FOCUSED
 
 // Bug in headers, sometimes
 #ifndef TVIS_FOCUSED


@@ -62,7 +81,7 @@ struct wxTreeViewItem : public TV_ITEM
     {
         mask = mask_;
         stateMask = stateMask_;
     {
         mask = mask_;
         stateMask = stateMask_;

-        hItem = (HTREEITEM)item;
+        hItem = (HTREEITEM) (WXHTREEITEM) item;

     }
 };
 
     }
 };
 


@@ -75,7 +94,7 @@ struct wxTreeViewItem : public TV_ITEM
 #endif
 
 // hide the ugly cast (of course, the macro is _quite_ ugly too...)
 #endif
 
 // hide the ugly cast (of course, the macro is _quite_ ugly too...)

-#define hwnd    ((HWND)m_hWnd)
+#define wxhWnd    ((HWND)m_hWnd)

 
 // ----------------------------------------------------------------------------
 // variables
 
 // ----------------------------------------------------------------------------
 // variables


@@ -121,7 +140,8 @@ bool wxTreeCtrl::Create(wxWindow *parent, wxWindowID id,
 
     m_windowId = (id == -1) ? NewControlId() : id;
 
 
     m_windowId = (id == -1) ? NewControlId() : id;
 

-    DWORD wstyle = WS_VISIBLE | WS_CHILD | WS_TABSTOP | TVS_HASLINES;
+    DWORD wstyle = WS_VISIBLE | WS_CHILD | WS_TABSTOP | TVS_HASLINES | TVS_SHOWSELALWAYS ;
+

 
     bool want3D;
     WXDWORD exStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &want3D) ;
 
     bool want3D;
     WXDWORD exStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &want3D) ;


@@ -182,7 +202,7 @@ wxTreeCtrl::~wxTreeCtrl()
 
 bool wxTreeCtrl::DoGetItem(wxTreeViewItem* tvItem) const
 {
 
 bool wxTreeCtrl::DoGetItem(wxTreeViewItem* tvItem) const
 {

-    if ( !TreeView_GetItem(hwnd, tvItem) )
+    if ( !TreeView_GetItem(wxhWnd, tvItem) )

     {
         wxLogLastError("TreeView_GetItem");
 
     {
         wxLogLastError("TreeView_GetItem");
 


@@ -194,7 +214,7 @@ bool wxTreeCtrl::DoGetItem(wxTreeViewItem* tvItem) const
 
 void wxTreeCtrl::DoSetItem(wxTreeViewItem* tvItem)
 {
 
 void wxTreeCtrl::DoSetItem(wxTreeViewItem* tvItem)
 {

-    if ( TreeView_SetItem(hwnd, tvItem) == -1 )
+    if ( TreeView_SetItem(wxhWnd, tvItem) == -1 )

     {
         wxLogLastError("TreeView_SetItem");
     }
     {
         wxLogLastError("TreeView_SetItem");
     }


@@ -202,17 +222,17 @@ void wxTreeCtrl::DoSetItem(wxTreeViewItem* tvItem)
 
 size_t wxTreeCtrl::GetCount() const
 {
 
 size_t wxTreeCtrl::GetCount() const
 {

-    return (size_t)TreeView_GetCount(hwnd);
+    return (size_t)TreeView_GetCount(wxhWnd);

 }
 
 unsigned int wxTreeCtrl::GetIndent() const
 {
 }
 
 unsigned int wxTreeCtrl::GetIndent() const
 {

-    return TreeView_GetIndent(hwnd);
+    return TreeView_GetIndent(wxhWnd);

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

-    TreeView_SetIndent(hwnd, indent);
+    TreeView_SetIndent(wxhWnd, indent);

 }
 
 wxImageList *wxTreeCtrl::GetImageList() const
 }
 
 wxImageList *wxTreeCtrl::GetImageList() const


@@ -228,7 +248,7 @@ wxImageList *wxTreeCtrl::GetStateImageList() const
 void wxTreeCtrl::SetAnyImageList(wxImageList *imageList, int which)
 {
     // no error return
 void wxTreeCtrl::SetAnyImageList(wxImageList *imageList, int which)
 {
     // no error return

-    TreeView_SetImageList(hwnd,
+    TreeView_SetImageList(wxhWnd,

                           imageList ? imageList->GetHIMAGELIST() : 0,
                           which);
 }
                           imageList ? imageList->GetHIMAGELIST() : 0,
                           which);
 }


@@ -243,6 +263,31 @@ void wxTreeCtrl::SetStateImageList(wxImageList *imageList)
     SetAnyImageList(m_imageListState = imageList, TVSIL_STATE);
 }
 
     SetAnyImageList(m_imageListState = imageList, TVSIL_STATE);
 }
 

+size_t wxTreeCtrl::GetChildrenCount(const wxTreeItemId& item, bool recursively)
+{
+    long cookie;
+
+    size_t result = 0;
+
+    wxArrayLong children;
+    wxTreeItemId child = GetFirstChild(item, cookie);
+    while ( child.IsOk() )
+    {
+        if ( recursively )
+        {
+            // recursive call
+            result += GetChildrenCount(child, TRUE);
+        }
+
+        // add the child to the result in any case
+        result++;
+
+        child = GetNextChild(item, cookie);
+    }
+
+    return result;
+}
+

 // ----------------------------------------------------------------------------
 // Item access
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // Item access
 // ----------------------------------------------------------------------------


@@ -308,14 +353,7 @@ wxTreeItemData *wxTreeCtrl::GetItemData(const wxTreeItemId& item) const
         return NULL;
     }
 
         return NULL;
     }
 

-    wxTreeItemData *data = (wxTreeItemData *)tvItem.lParam;
-    if ( data != NULL )
-    {
-        // the data object should know about its id
-        data->m_itemId = item;
-    }
-
-    return data;
+    return (wxTreeItemData *)tvItem.lParam;

 }
 
 void wxTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data)
 }
 
 void wxTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data)


@@ -325,14 +363,37 @@ void wxTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data)
     DoSetItem(&tvItem);
 }
 
     DoSetItem(&tvItem);
 }
 

+void wxTreeCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
+{
+    wxTreeViewItem tvItem(item, TVIF_CHILDREN);
+    tvItem.cChildren = (int)has;
+    DoSetItem(&tvItem);
+}
+
+void wxTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
+{
+    wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_BOLD);
+    tvItem.state = bold ? TVIS_BOLD : 0;
+    DoSetItem(&tvItem);
+}
+
+void wxTreeCtrl::SetItemDropHighlight(const wxTreeItemId& item, bool highlight)
+{
+    wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_DROPHILITED);
+    tvItem.state = highlight ? TVIS_DROPHILITED : 0;
+    DoSetItem(&tvItem);
+}
+

 // ----------------------------------------------------------------------------
 // Item status
 // ----------------------------------------------------------------------------
 
 bool wxTreeCtrl::IsVisible(const wxTreeItemId& item) const
 {
 // ----------------------------------------------------------------------------
 // Item status
 // ----------------------------------------------------------------------------
 
 bool wxTreeCtrl::IsVisible(const wxTreeItemId& item) const
 {

+    // Bug in Gnu-Win32 headers, so don't use the macro TreeView_GetItemRect

     RECT rect;
     RECT rect;

-    return TreeView_GetItemRect(hwnd, (HTREEITEM)item, &rect, FALSE) != 0;
+    return SendMessage(wxhWnd, TVM_GETITEMRECT, FALSE, (LPARAM)&rect) != 0;
+

 }
 
 bool wxTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const
 }
 
 bool wxTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const


@@ -362,54 +423,81 @@ bool wxTreeCtrl::IsSelected(const wxTreeItemId& item) const
     return (tvItem.state & TVIS_SELECTED) != 0;
 }
 
     return (tvItem.state & TVIS_SELECTED) != 0;
 }
 

+bool wxTreeCtrl::IsBold(const wxTreeItemId& item) const
+{
+    wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_BOLD);
+    DoGetItem(&tvItem);
+
+    return (tvItem.state & TVIS_BOLD) != 0;
+}
+

 // ----------------------------------------------------------------------------
 // navigation
 // ----------------------------------------------------------------------------
 
 wxTreeItemId wxTreeCtrl::GetRootItem() const
 {
 // ----------------------------------------------------------------------------
 // navigation
 // ----------------------------------------------------------------------------
 
 wxTreeItemId wxTreeCtrl::GetRootItem() const
 {

-    return wxTreeItemId(TreeView_GetRoot(hwnd));
+    return wxTreeItemId((WXHTREEITEM) TreeView_GetRoot(wxhWnd));

 }
 
 wxTreeItemId wxTreeCtrl::GetSelection() const
 {
 }
 
 wxTreeItemId wxTreeCtrl::GetSelection() const
 {

-    return wxTreeItemId(TreeView_GetSelection(hwnd));
+    return wxTreeItemId((WXHTREEITEM) TreeView_GetSelection(wxhWnd));

 }
 
 wxTreeItemId wxTreeCtrl::GetParent(const wxTreeItemId& item) const
 {
 }
 
 wxTreeItemId wxTreeCtrl::GetParent(const wxTreeItemId& item) const
 {

-    return wxTreeItemId(TreeView_GetParent(hwnd, item));
+    return wxTreeItemId((WXHTREEITEM) TreeView_GetParent(wxhWnd, (HTREEITEM) (WXHTREEITEM) item));

 }
 
 wxTreeItemId wxTreeCtrl::GetFirstChild(const wxTreeItemId& item,
 }
 
 wxTreeItemId wxTreeCtrl::GetFirstChild(const wxTreeItemId& item,

-                                       long& cookie) const
+                                       long& _cookie) const

 {
     // remember the last child returned in 'cookie'
 {
     // remember the last child returned in 'cookie'

-    cookie = (long)TreeView_GetChild(hwnd, (HTREEITEM)item);
+    _cookie = (long)TreeView_GetChild(wxhWnd, (HTREEITEM) (WXHTREEITEM)item);

 
 

-    return wxTreeItemId((HTREEITEM)cookie);
+    return wxTreeItemId((WXHTREEITEM)_cookie);

 }
 
 wxTreeItemId wxTreeCtrl::GetNextChild(const wxTreeItemId& WXUNUSED(item),
 }
 
 wxTreeItemId wxTreeCtrl::GetNextChild(const wxTreeItemId& WXUNUSED(item),

-                                      long& cookie) const
+                                      long& _cookie) const

 {
 {

-    return wxTreeItemId(TreeView_GetNextSibling(hwnd,
-                                                    (HTREEITEM)cookie));
+    wxTreeItemId l = wxTreeItemId((WXHTREEITEM)TreeView_GetNextSibling(wxhWnd,
+                                   (HTREEITEM)(WXHTREEITEM)_cookie));
+    _cookie = (long)l;
+
+    return l;
+}
+
+wxTreeItemId wxTreeCtrl::GetLastChild(const wxTreeItemId& item) const
+{
+    // can this be done more efficiently?
+    long cookie;
+
+    wxTreeItemId childLast,
+    child = GetFirstChild(item, cookie);
+    while ( child.IsOk() )
+    {
+        childLast = child;
+        child = GetNextChild(item, cookie);
+    }
+
+    return childLast;

 }
 
 wxTreeItemId wxTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
 {
 }
 
 wxTreeItemId wxTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
 {

-    return wxTreeItemId(TreeView_GetNextSibling(hwnd, item));
+    return wxTreeItemId((WXHTREEITEM) TreeView_GetNextSibling(wxhWnd, (HTREEITEM) (WXHTREEITEM) item));

 }
 
 wxTreeItemId wxTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const
 {
 }
 
 wxTreeItemId wxTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const
 {

-    return wxTreeItemId(TreeView_GetPrevSibling(hwnd, item));
+    return wxTreeItemId((WXHTREEITEM) TreeView_GetPrevSibling(wxhWnd, (HTREEITEM) (WXHTREEITEM) item));

 }
 
 wxTreeItemId wxTreeCtrl::GetFirstVisibleItem() const
 {
 }
 
 wxTreeItemId wxTreeCtrl::GetFirstVisibleItem() const
 {

-    return wxTreeItemId(TreeView_GetFirstVisible(hwnd));
+    return wxTreeItemId((WXHTREEITEM) TreeView_GetFirstVisible(wxhWnd));

 }
 
 wxTreeItemId wxTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
 }
 
 wxTreeItemId wxTreeCtrl::GetNextVisible(const wxTreeItemId& item) const


@@ -417,7 +505,7 @@ wxTreeItemId wxTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
     wxASSERT_MSG( IsVisible(item), "The item you call GetNextVisible() "
                                    "for must be visible itself!");
 
     wxASSERT_MSG( IsVisible(item), "The item you call GetNextVisible() "
                                    "for must be visible itself!");
 

-    return wxTreeItemId(TreeView_GetNextVisible(hwnd, item));
+    return wxTreeItemId((WXHTREEITEM) TreeView_GetNextVisible(wxhWnd, (HTREEITEM) (WXHTREEITEM) item));

 }
 
 wxTreeItemId wxTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
 }
 
 wxTreeItemId wxTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const


@@ -425,7 +513,7 @@ wxTreeItemId wxTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
     wxASSERT_MSG( IsVisible(item), "The item you call GetPrevVisible() "
                                    "for must be visible itself!");
 
     wxASSERT_MSG( IsVisible(item), "The item you call GetPrevVisible() "
                                    "for must be visible itself!");
 

-    return wxTreeItemId(TreeView_GetPrevVisible(hwnd, item));
+    return wxTreeItemId((WXHTREEITEM) TreeView_GetPrevVisible(wxhWnd, (HTREEITEM) (WXHTREEITEM) item));

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


@@ -439,8 +527,15 @@ wxTreeItemId wxTreeCtrl::DoInsertItem(const wxTreeItemId& parent,
                                       wxTreeItemData *data)
 {
     TV_INSERTSTRUCT tvIns;
                                       wxTreeItemData *data)
 {
     TV_INSERTSTRUCT tvIns;

-    tvIns.hParent = (HTREEITEM)parent;
-    tvIns.hInsertAfter = hInsertAfter;
+    tvIns.hParent = (HTREEITEM) (WXHTREEITEM)parent;
+    tvIns.hInsertAfter = (HTREEITEM) (WXHTREEITEM) hInsertAfter;
+
+    // This is how we insert the item as the first child: supply a NULL hInsertAfter
+    if (tvIns.hInsertAfter == (HTREEITEM) 0)
+    {
+        tvIns.hInsertAfter = TVI_FIRST;
+    }
+

     UINT mask = 0;
     if ( !text.IsEmpty() )
     {
     UINT mask = 0;
     if ( !text.IsEmpty() )
     {


@@ -452,6 +547,12 @@ wxTreeItemId wxTreeCtrl::DoInsertItem(const wxTreeItemId& parent,
     {
         mask |= TVIF_IMAGE;
         tvIns.item.iImage = image;
     {
         mask |= TVIF_IMAGE;
         tvIns.item.iImage = image;

+
+        if ( selectedImage == -1 )
+        {
+            // take the same image for selected icon if not specified
+            selectedImage = image;
+        }

     }
 
     if ( selectedImage != -1 )
     }
 
     if ( selectedImage != -1 )


@@ -468,13 +569,19 @@ wxTreeItemId wxTreeCtrl::DoInsertItem(const wxTreeItemId& parent,
 
     tvIns.item.mask = mask;
 
 
     tvIns.item.mask = mask;
 

-    HTREEITEM id = TreeView_InsertItem(hwnd, &tvIns);
+    HTREEITEM id = (HTREEITEM) TreeView_InsertItem(wxhWnd, &tvIns);

     if ( id == 0 )
     {
         wxLogLastError("TreeView_InsertItem");
     }
 
     if ( id == 0 )
     {
         wxLogLastError("TreeView_InsertItem");
     }
 

-    return wxTreeItemId(id);
+    if ( data != NULL )
+    {
+        // associate the application tree item with Win32 tree item handle
+        data->SetId((WXHTREEITEM)id);
+    }
+
+    return wxTreeItemId((WXHTREEITEM)id);

 }
 
 // for compatibility only
 }
 
 // for compatibility only


@@ -483,7 +590,7 @@ wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parent,
                                     int image, int selImage,
                                     long insertAfter)
 {
                                     int image, int selImage,
                                     long insertAfter)
 {

-    return DoInsertItem(parent, (HTREEITEM)insertAfter, text,
+    return DoInsertItem(parent, (WXHTREEITEM)insertAfter, text,

                         image, selImage, NULL);
 }
 
                         image, selImage, NULL);
 }
 


@@ -491,7 +598,7 @@ wxTreeItemId wxTreeCtrl::AddRoot(const wxString& text,
                                  int image, int selectedImage,
                                  wxTreeItemData *data)
 {
                                  int image, int selectedImage,
                                  wxTreeItemData *data)
 {

-    return DoInsertItem(wxTreeItemId(0), 0,
+    return DoInsertItem(wxTreeItemId((WXHTREEITEM) 0), (WXHTREEITEM) 0,

                         text, image, selectedImage, data);
 }
 
                         text, image, selectedImage, data);
 }
 


@@ -500,7 +607,7 @@ wxTreeItemId wxTreeCtrl::PrependItem(const wxTreeItemId& parent,
                                      int image, int selectedImage,
                                      wxTreeItemData *data)
 {
                                      int image, int selectedImage,
                                      wxTreeItemData *data)
 {

-    return DoInsertItem(parent, TVI_FIRST,
+    return DoInsertItem(parent, (WXHTREEITEM) TVI_FIRST,

                         text, image, selectedImage, data);
 }
 
                         text, image, selectedImage, data);
 }
 


@@ -518,24 +625,45 @@ wxTreeItemId wxTreeCtrl::AppendItem(const wxTreeItemId& parent,
                                     int image, int selectedImage,
                                     wxTreeItemData *data)
 {
                                     int image, int selectedImage,
                                     wxTreeItemData *data)
 {

-    return DoInsertItem(parent, TVI_LAST,
+    return DoInsertItem(parent, (WXHTREEITEM) TVI_LAST,

                         text, image, selectedImage, data);
 }
 
 void wxTreeCtrl::Delete(const wxTreeItemId& item)
 {
                         text, image, selectedImage, data);
 }
 
 void wxTreeCtrl::Delete(const wxTreeItemId& item)
 {

-    wxTreeItemData *data = GetItemData(item);
-    delete data;    // may be NULL, ok
-
-    if ( !TreeView_DeleteItem(hwnd, (HTREEITEM)item) )
+    if ( !TreeView_DeleteItem(wxhWnd, (HTREEITEM)(WXHTREEITEM)item) )

     {
         wxLogLastError("TreeView_DeleteItem");
     }
 }
 
     {
         wxLogLastError("TreeView_DeleteItem");
     }
 }
 

+// delete all children (but don't delete the item itself)
+void wxTreeCtrl::DeleteChildren(const wxTreeItemId& item)
+{
+    long cookie;
+
+    wxArrayLong children;
+    wxTreeItemId child = GetFirstChild(item, cookie);
+    while ( child.IsOk() )
+    {
+        children.Add((long)(WXHTREEITEM)child);
+
+        child = GetNextChild(item, cookie);
+    }
+
+    size_t nCount = children.Count();
+    for ( size_t n = 0; n < nCount; n++ )
+    {
+        if ( !TreeView_DeleteItem(wxhWnd, (HTREEITEM)children[n]) )
+        {
+            wxLogLastError("TreeView_DeleteItem");
+        }
+    }
+}
+

 void wxTreeCtrl::DeleteAllItems()
 {
 void wxTreeCtrl::DeleteAllItems()
 {

-    if ( !TreeView_DeleteAllItems(hwnd) )
+    if ( !TreeView_DeleteAllItems(wxhWnd) )

     {
         wxLogLastError("TreeView_DeleteAllItems");
     }
     {
         wxLogLastError("TreeView_DeleteAllItems");
     }


@@ -543,13 +671,15 @@ void wxTreeCtrl::DeleteAllItems()
 
 void wxTreeCtrl::DoExpand(const wxTreeItemId& item, int flag)
 {
 
 void wxTreeCtrl::DoExpand(const wxTreeItemId& item, int flag)
 {

-    wxASSERT_MSG( flag == TVE_COLLAPSE || flag == TVE_COLLAPSERESET ||
-                  flag == TVE_EXPAND   || flag == TVE_TOGGLE,
+    wxASSERT_MSG( flag == TVE_COLLAPSE ||
+                  flag == (TVE_COLLAPSE | TVE_COLLAPSERESET) ||
+                  flag == TVE_EXPAND   ||
+                  flag == TVE_TOGGLE,

                   "Unknown flag in wxTreeCtrl::DoExpand" );
 
     // TreeView_Expand doesn't send TVN_ITEMEXPAND(ING) messages, so we must
     // emulate them
                   "Unknown flag in wxTreeCtrl::DoExpand" );
 
     // TreeView_Expand doesn't send TVN_ITEMEXPAND(ING) messages, so we must
     // emulate them

-    if ( TreeView_Expand(hwnd, item, flag) != 0 )
+    if ( TreeView_Expand(wxhWnd, (HTREEITEM) (WXHTREEITEM) item, flag) != 0 )

     {
         wxTreeEvent event(wxEVT_NULL, m_windowId);
         event.m_item = item;
     {
         wxTreeEvent event(wxEVT_NULL, m_windowId);
         event.m_item = item;


@@ -584,7 +714,7 @@ void wxTreeCtrl::Collapse(const wxTreeItemId& item)
 
 void wxTreeCtrl::CollapseAndReset(const wxTreeItemId& item)
 {
 
 void wxTreeCtrl::CollapseAndReset(const wxTreeItemId& item)
 {

-    DoExpand(item, TVE_COLLAPSERESET);
+    DoExpand(item, TVE_COLLAPSE | TVE_COLLAPSERESET);

 }
 
 void wxTreeCtrl::Toggle(const wxTreeItemId& item)
 }
 
 void wxTreeCtrl::Toggle(const wxTreeItemId& item)


@@ -592,14 +722,19 @@ void wxTreeCtrl::Toggle(const wxTreeItemId& item)
     DoExpand(item, TVE_TOGGLE);
 }
 
     DoExpand(item, TVE_TOGGLE);
 }
 

+void wxTreeCtrl::ExpandItem(const wxTreeItemId& item, int action)
+{
+       DoExpand(item, action);
+}
+

 void wxTreeCtrl::Unselect()
 {
 void wxTreeCtrl::Unselect()
 {

-    SelectItem(wxTreeItemId(0));
+    SelectItem(wxTreeItemId((WXHTREEITEM) 0));

 }
 
 void wxTreeCtrl::SelectItem(const wxTreeItemId& item)
 {
 }
 
 void wxTreeCtrl::SelectItem(const wxTreeItemId& item)
 {

-    if ( !TreeView_SelectItem(hwnd, item) )
+    if ( !TreeView_SelectItem(wxhWnd, (HTREEITEM) (WXHTREEITEM) item) )

     {
         wxLogLastError("TreeView_SelectItem");
     }
     {
         wxLogLastError("TreeView_SelectItem");
     }


@@ -608,12 +743,12 @@ void wxTreeCtrl::SelectItem(const wxTreeItemId& item)
 void wxTreeCtrl::EnsureVisible(const wxTreeItemId& item)
 {
     // no error return
 void wxTreeCtrl::EnsureVisible(const wxTreeItemId& item)
 {
     // no error return

-    TreeView_EnsureVisible(hwnd, item);
+    TreeView_EnsureVisible(wxhWnd, (HTREEITEM) (WXHTREEITEM) item);

 }
 
 void wxTreeCtrl::ScrollTo(const wxTreeItemId& item)
 {
 }
 
 void wxTreeCtrl::ScrollTo(const wxTreeItemId& item)
 {

-    if ( !TreeView_SelectSetFirstVisible(hwnd, item) )
+    if ( !TreeView_SelectSetFirstVisible(wxhWnd, (HTREEITEM) (WXHTREEITEM) item) )

     {
         wxLogLastError("TreeView_SelectSetFirstVisible");
     }
     {
         wxLogLastError("TreeView_SelectSetFirstVisible");
     }


@@ -640,7 +775,7 @@ wxTextCtrl* wxTreeCtrl::EditLabel(const wxTreeItemId& item,
 {
     wxASSERT( textControlClass->IsKindOf(CLASSINFO(wxTextCtrl)) );
 
 {
     wxASSERT( textControlClass->IsKindOf(CLASSINFO(wxTextCtrl)) );
 

-    HWND hWnd = TreeView_EditLabel(hwnd, item);
+    HWND hWnd = (HWND) TreeView_EditLabel(wxhWnd, (HTREEITEM) (WXHTREEITEM) item);

 
     wxCHECK_MSG( hWnd, NULL, "Can't edit tree ctrl label" );
 
 
     wxCHECK_MSG( hWnd, NULL, "Can't edit tree ctrl label" );
 


@@ -656,7 +791,7 @@ wxTextCtrl* wxTreeCtrl::EditLabel(const wxTreeItemId& item,
 // End label editing, optionally cancelling the edit
 void wxTreeCtrl::EndEditLabel(const wxTreeItemId& item, bool discardChanges)
 {
 // End label editing, optionally cancelling the edit
 void wxTreeCtrl::EndEditLabel(const wxTreeItemId& item, bool discardChanges)
 {

-    TreeView_EndEditLabelNow(hwnd, discardChanges);
+    TreeView_EndEditLabelNow(wxhWnd, discardChanges);

 
     DeleteTextCtrl();
 }
 
     DeleteTextCtrl();
 }


@@ -667,7 +802,7 @@ wxTreeItemId wxTreeCtrl::HitTest(const wxPoint& point, int& flags)
     hitTestInfo.pt.x = (int)point.x;
     hitTestInfo.pt.y = (int)point.y;
 
     hitTestInfo.pt.x = (int)point.x;
     hitTestInfo.pt.y = (int)point.y;
 

-    TreeView_HitTest(hwnd, &hitTestInfo);
+    TreeView_HitTest(wxhWnd, &hitTestInfo);

 
     flags = 0;
 
 
     flags = 0;
 


@@ -689,20 +824,61 @@ wxTreeItemId wxTreeCtrl::HitTest(const wxPoint& point, int& flags)
 
     #undef TRANSLATE_FLAG
 
 
     #undef TRANSLATE_FLAG
 

-    return wxTreeItemId(hitTestInfo.hItem);
+    return wxTreeItemId((WXHTREEITEM) hitTestInfo.hItem);
+}
+
+bool wxTreeCtrl::GetBoundingRect(const wxTreeItemId& item,
+                                 wxRect& rect,
+                                 bool textOnly) const
+{
+    RECT rc;
+    if ( TreeView_GetItemRect(wxhWnd, (HTREEITEM)(WXHTREEITEM)item,
+                              &rc, textOnly) )
+    {
+        rect = wxRect(wxPoint(rc.left, rc.top), wxPoint(rc.right, rc.bottom));
+
+        return TRUE;
+    }
+    else
+    {
+        // couldn't retrieve rect: for example, item isn't visible
+        return FALSE;
+    }
+}
+
+// ----------------------------------------------------------------------------
+// sorting stuff
+// ----------------------------------------------------------------------------
+
+static int CALLBACK TreeView_CompareCallback(wxTreeItemData *pItem1,
+                                             wxTreeItemData *pItem2,
+                                             wxTreeCtrl *tree)
+{
+    return tree->OnCompareItems(pItem1->GetId(), pItem2->GetId());
+}
+
+int wxTreeCtrl::OnCompareItems(const wxTreeItemId& item1,
+                               const wxTreeItemId& item2)
+{
+    return strcmp(GetItemText(item1), GetItemText(item2));

 }
 
 }
 

-void wxTreeCtrl::SortChildren(const wxTreeItemId& item,
-                              wxTreeItemCmpFunc *cmpFunction)
+void wxTreeCtrl::SortChildren(const wxTreeItemId& item)

 {
 {

-    if ( cmpFunction == NULL )
+    // rely on the fact that TreeView_SortChildren does the same thing as our
+    // default behaviour, i.e. sorts items alphabetically and so call it
+    // directly if we're not in derived class (much more efficient!)
+    if ( GetClassInfo() == CLASSINFO(wxTreeCtrl) )

     {
     {

-        TreeView_SortChildren(hwnd, item, 0);
+        TreeView_SortChildren(wxhWnd, (HTREEITEM)(WXHTREEITEM)item, 0);

     }
     else
     {
     }
     else
     {

-        // TODO: use TreeView_SortChildrenCB
-        wxFAIL_MSG("wxTreeCtrl::SortChildren not implemented");
+        TV_SORTCB tvSort;
+        tvSort.hParent = (HTREEITEM)(WXHTREEITEM)item;
+        tvSort.lpfnCompare = (PFNTVCOMPARE)TreeView_CompareCallback;
+        tvSort.lParam = (LPARAM)this;
+        TreeView_SortChildrenCB(wxhWnd, &tvSort, 0 /* reserved */);

     }
 }
 
     }
 }
 


@@ -735,7 +911,7 @@ bool wxTreeCtrl::MSWCommand(WXUINT cmd, WXWORD id)
 }
 
 // process WM_NOTIFY Windows message
 }
 
 // process WM_NOTIFY Windows message

-bool wxTreeCtrl::MSWNotify(WXWPARAM wParam, WXLPARAM lParam)
+bool wxTreeCtrl::MSWNotify(WXWPARAM wParam, WXLPARAM lParam, WXLPARAM *result)

 {
     wxTreeEvent event(wxEVT_NULL, m_windowId);
     wxEventType eventType = wxEVT_NULL;
 {
     wxTreeEvent event(wxEVT_NULL, m_windowId);
     wxEventType eventType = wxEVT_NULL;


@@ -755,7 +931,7 @@ bool wxTreeCtrl::MSWNotify(WXWPARAM wParam, WXLPARAM lParam)
 
                 NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
 
 
                 NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
 

-                event.m_item = tv->itemNew.hItem;
+                event.m_item = (WXHTREEITEM) tv->itemNew.hItem;

                 event.m_pointDrag = wxPoint(tv->ptDrag.x, tv->ptDrag.y);
                 break;
             }
                 event.m_pointDrag = wxPoint(tv->ptDrag.x, tv->ptDrag.y);
                 break;
             }


@@ -765,7 +941,7 @@ bool wxTreeCtrl::MSWNotify(WXWPARAM wParam, WXLPARAM lParam)
                 eventType = wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT;
                 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
 
                 eventType = wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT;
                 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
 

-                event.m_item = info->item.hItem;
+                event.m_item = (WXHTREEITEM) info->item.hItem;

                 break;
             }
 
                 break;
             }
 


@@ -774,7 +950,7 @@ bool wxTreeCtrl::MSWNotify(WXWPARAM wParam, WXLPARAM lParam)
                 eventType = wxEVT_COMMAND_TREE_DELETE_ITEM;
                 NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
 
                 eventType = wxEVT_COMMAND_TREE_DELETE_ITEM;
                 NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
 

-                event.m_item = tv->itemOld.hItem;
+                event.m_item = (WXHTREEITEM) tv->itemOld.hItem;

                 break;
             }
 
                 break;
             }
 


@@ -783,7 +959,7 @@ bool wxTreeCtrl::MSWNotify(WXWPARAM wParam, WXLPARAM lParam)
                 eventType = wxEVT_COMMAND_TREE_END_LABEL_EDIT;
                 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
 
                 eventType = wxEVT_COMMAND_TREE_END_LABEL_EDIT;
                 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
 

-                event.m_item = info->item.hItem;
+                event.m_item = (WXHTREEITEM) info->item.hItem;

                 break;
             }
 
                 break;
             }
 


@@ -799,7 +975,7 @@ bool wxTreeCtrl::MSWNotify(WXWPARAM wParam, WXLPARAM lParam)
 
                 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
 
 
                 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
 

-                event.m_item = info->item.hItem;
+                event.m_item = (WXHTREEITEM) info->item.hItem;

                 break;
             }
 
                 break;
             }
 


@@ -827,10 +1003,10 @@ bool wxTreeCtrl::MSWNotify(WXWPARAM wParam, WXLPARAM lParam)
                                    "message", tv->action);
                 }
 
                                    "message", tv->action);
                 }
 

-                bool ing = hdr->code == TVN_ITEMEXPANDING;
+                bool ing = (hdr->code == TVN_ITEMEXPANDING);

                 eventType = g_events[expand][ing];
 
                 eventType = g_events[expand][ing];
 

-                event.m_item = tv->itemNew.hItem;
+                event.m_item = (WXHTREEITEM) tv->itemNew.hItem;

                 break;
             }
 
                 break;
             }
 


@@ -840,6 +1016,16 @@ bool wxTreeCtrl::MSWNotify(WXWPARAM wParam, WXLPARAM lParam)
                 TV_KEYDOWN *info = (TV_KEYDOWN *)lParam;
 
                 event.m_code = wxCharCodeMSWToWX(info->wVKey);
                 TV_KEYDOWN *info = (TV_KEYDOWN *)lParam;
 
                 event.m_code = wxCharCodeMSWToWX(info->wVKey);

+
+                // a separate event for this case
+                if ( info->wVKey == VK_SPACE || info->wVKey == VK_RETURN )
+                {
+                    wxTreeEvent event2(wxEVT_COMMAND_TREE_ITEM_ACTIVATED,
+                                       m_windowId);
+                    event2.SetEventObject(this);
+
+                    GetEventHandler()->ProcessEvent(event2);
+                }

                 break;
             }
 
                 break;
             }
 


@@ -855,52 +1041,45 @@ bool wxTreeCtrl::MSWNotify(WXWPARAM wParam, WXLPARAM lParam)
 
                 NM_TREEVIEW* tv = (NM_TREEVIEW *)lParam;
 
 
                 NM_TREEVIEW* tv = (NM_TREEVIEW *)lParam;
 

-                event.m_item = tv->itemNew.hItem;
-                event.m_itemOld = tv->itemOld.hItem;
+                event.m_item = (WXHTREEITEM) tv->itemNew.hItem;
+                event.m_itemOld = (WXHTREEITEM) tv->itemOld.hItem;

                 break;
             }
 
         default:
                 break;
             }
 
         default:

-            return wxControl::MSWNotify(wParam, lParam);
+            return wxControl::MSWNotify(wParam, lParam, result);

     }
 
     event.SetEventObject(this);
     event.SetEventType(eventType);
 
     }
 
     event.SetEventObject(this);
     event.SetEventType(eventType);
 

-    bool rc = GetEventHandler()->ProcessEvent(event);
+    bool processed = GetEventHandler()->ProcessEvent(event);

 
     // post processing
 
     // post processing

-    switch ( hdr->code )
+    if ( hdr->code == TVN_DELETEITEM )

     {
         // NB: we might process this message using wxWindows event tables, but
         //     due to overhead of wxWin event system we prefer to do it here
         //     (otherwise deleting a tree with many items is just too slow)
     {
         // NB: we might process this message using wxWindows event tables, but
         //     due to overhead of wxWin event system we prefer to do it here
         //     (otherwise deleting a tree with many items is just too slow)

-        case TVN_DELETEITEM:
-            {
-                NM_TREEVIEW* tv = (NM_TREEVIEW *)lParam;
-                wxTreeItemData *data = (wxTreeItemData *)tv->itemOld.lParam;
-                delete data; // may be NULL, ok
-            }
-            break;
-
-        case TVN_ITEMEXPANDING:
-            // if user called Veto(), don't allow expansion/collapse by
-            // returning TRUE from here
-            rc = event.m_code != 0;
-            break;
+        NM_TREEVIEW* tv = (NM_TREEVIEW *)lParam;
+        wxTreeItemData *data = (wxTreeItemData *)tv->itemOld.lParam;
+        delete data; // may be NULL, ok
+        processed = TRUE; // Make sure we don't get called twice

     }
 
     }
 

-    return rc;
+    *result = !event.IsAllowed();
+
+    return processed;

 }
 
 // ----------------------------------------------------------------------------
 // Tree event
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // Tree event
 // ----------------------------------------------------------------------------
 

-IMPLEMENT_DYNAMIC_CLASS(wxTreeEvent, wxCommandEvent)
+IMPLEMENT_DYNAMIC_CLASS(wxTreeEvent, wxNotifyEvent)

 
 wxTreeEvent::wxTreeEvent(wxEventType commandType, int id)
 
 wxTreeEvent::wxTreeEvent(wxEventType commandType, int id)

-           : wxCommandEvent(commandType, id)
+           : wxNotifyEvent(commandType, id)

 {
     m_code = 0;
     m_itemOld = 0;
 {
     m_code = 0;
     m_itemOld = 0;