Fix docs for Bind

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

diff --git a/src/msw/treectrl.cpp b/src/msw/treectrl.cpp
index 4481d863870a77de4e18aa2d05058f8c5983b432..a488f9c547c203eadd43b50a047e7b2e55e4a981 100644 (file)
--- a/src/msw/treectrl.cpp
+++ b/src/msw/treectrl.cpp
@@ -17,7 +17,7 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)

     #pragma implementation "treectrl.h"
 #endif
 
     #pragma implementation "treectrl.h"
 #endif
 


@@ -36,17 +36,6 @@
 // comctl32.dll versions
 #define wxUSE_COMCTL32_SAFELY 0
 
 // comctl32.dll versions
 #define wxUSE_COMCTL32_SAFELY 0
 

-// Mingw32 is a bit mental even though this is done in winundef
-#ifdef GetFirstChild
-    #undef GetFirstChild
-#endif
-
-#ifdef GetNextSibling
-    #undef GetNextSibling
-#endif
-
-#if defined(__WIN95__)
-

 #include "wx/app.h"
 #include "wx/log.h"
 #include "wx/dynarray.h"
 #include "wx/app.h"
 #include "wx/log.h"
 #include "wx/dynarray.h"


@@ -55,39 +44,17 @@
 #include "wx/msw/treectrl.h"
 #include "wx/msw/dragimag.h"
 
 #include "wx/msw/treectrl.h"
 #include "wx/msw/dragimag.h"
 

-#ifdef __GNUWIN32_OLD__
-    #include "wx/msw/gnuwin32/extra.h"
-#endif
-
-#if defined(__WIN95__) && !((defined(__GNUWIN32_OLD__) || defined(__TWIN32__)) && !defined(__CYGWIN10__))
-    #include <commctrl.h>
-#endif
+// include <commctrl.h> "properly"
+#include "wx/msw/wrapcctl.h"

 
 

-// Bug in headers, sometimes
-#ifndef TVIS_FOCUSED
-    #define TVIS_FOCUSED            0x0001
-#endif
+// macros to hide the cast ugliness
+// --------------------------------

 
 

-#ifndef TV_FIRST
-    #define TV_FIRST                0x1100
-#endif
+// ptr is the real item id, i.e. wxTreeItemId::m_pItem
+#define HITEM_PTR(ptr)     (HTREEITEM)(ptr)

 
 

-#ifndef TVS_CHECKBOXES
-    #define TVS_CHECKBOXES          0x0100
-#endif
-
-#ifndef TVS_FULLROWSELECT
-    #define TVS_FULLROWSELECT       0x1000
-#endif
-
-// old headers might miss these messages (comctl32.dll 4.71+ only)
-#ifndef TVM_SETBKCOLOR
-    #define TVM_SETBKCOLOR          (TV_FIRST + 29)
-    #define TVM_SETTEXTCOLOR        (TV_FIRST + 30)
-#endif
-
-// a macro to hide the ugliness of nested casts
-#define HITEM(item)     (HTREEITEM)(WXHTREEITEM)(item)
+// item here is a wxTreeItemId
+#define HITEM(item)     HITEM_PTR((item).m_pItem)

 
 // the native control doesn't support multiple selections under MSW and we
 // have 2 ways to emulate them: either using TVS_CHECKBOXES style and let
 
 // the native control doesn't support multiple selections under MSW and we
 // have 2 ways to emulate them: either using TVS_CHECKBOXES style and let


@@ -97,7 +64,6 @@
 // looks quite ugly.
 #define wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE 0
 
 // looks quite ugly.
 #define wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE 0
 

-

 // ----------------------------------------------------------------------------
 // private functions
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // private functions
 // ----------------------------------------------------------------------------


@@ -117,6 +83,7 @@ static HTREEITEM GetItemFromPoint(HWND hwndTV, int x, int y)
 // wrappers for TreeView_GetItem/TreeView_SetItem
 static bool IsItemSelected(HWND hwndTV, HTREEITEM hItem)
 {
 // wrappers for TreeView_GetItem/TreeView_SetItem
 static bool IsItemSelected(HWND hwndTV, HTREEITEM hItem)
 {

+

     TV_ITEM tvi;
     tvi.mask = TVIF_STATE | TVIF_HANDLE;
     tvi.stateMask = TVIS_SELECTED;
     TV_ITEM tvi;
     tvi.mask = TVIF_STATE | TVIF_HANDLE;
     tvi.stateMask = TVIS_SELECTED;


@@ -130,7 +97,7 @@ static bool IsItemSelected(HWND hwndTV, HTREEITEM hItem)
     return (tvi.state & TVIS_SELECTED) != 0;
 }
 
     return (tvi.state & TVIS_SELECTED) != 0;
 }
 

-static void SelectItem(HWND hwndTV, HTREEITEM hItem, bool select = TRUE)
+static bool SelectItem(HWND hwndTV, HTREEITEM hItem, bool select = true)

 {
     TV_ITEM tvi;
     tvi.mask = TVIF_STATE | TVIF_HANDLE;
 {
     TV_ITEM tvi;
     tvi.mask = TVIF_STATE | TVIF_HANDLE;


@@ -141,12 +108,15 @@ static void SelectItem(HWND hwndTV, HTREEITEM hItem, bool select = TRUE)
     if ( TreeView_SetItem(hwndTV, &tvi) == -1 )
     {
         wxLogLastError(wxT("TreeView_SetItem"));
     if ( TreeView_SetItem(hwndTV, &tvi) == -1 )
     {
         wxLogLastError(wxT("TreeView_SetItem"));

+        return false;

     }
     }

+
+    return true;

 }
 
 static inline void UnselectItem(HWND hwndTV, HTREEITEM htItem)
 {
 }
 
 static inline void UnselectItem(HWND hwndTV, HTREEITEM htItem)
 {

-    SelectItem(hwndTV, htItem, FALSE);
+    SelectItem(hwndTV, htItem, false);

 }
 
 static inline void ToggleItemSelection(HWND hwndTV, HTREEITEM htItem)
 }
 
 static inline void ToggleItemSelection(HWND hwndTV, HTREEITEM htItem)


@@ -159,10 +129,10 @@ static inline void ToggleItemSelection(HWND hwndTV, HTREEITEM htItem)
 static void SelectRange(HWND hwndTV,
                         HTREEITEM htFirst,
                         HTREEITEM htLast,
 static void SelectRange(HWND hwndTV,
                         HTREEITEM htFirst,
                         HTREEITEM htLast,

-                        bool unselectOthers = TRUE)
+                        bool unselectOthers = true)

 {
     // find the first (or last) item and select it
 {
     // find the first (or last) item and select it

-    bool cont = TRUE;
+    bool cont = true;

     HTREEITEM htItem = (HTREEITEM)TreeView_GetRoot(hwndTV);
     while ( htItem && cont )
     {
     HTREEITEM htItem = (HTREEITEM)TreeView_GetRoot(hwndTV);
     while ( htItem && cont )
     {


@@ -173,7 +143,7 @@ static void SelectRange(HWND hwndTV,
                 SelectItem(hwndTV, htItem);
             }
 
                 SelectItem(hwndTV, htItem);
             }
 

-            cont = FALSE;
+            cont = false;

         }
         else
         {
         }
         else
         {


@@ -292,6 +262,8 @@ struct wxTreeViewItem : public TV_ITEM
                    UINT mask_,                  // fields which are valid
                    UINT stateMask_ = 0)         // for TVIF_STATE only
     {
                    UINT mask_,                  // fields which are valid
                    UINT stateMask_ = 0)         // for TVIF_STATE only
     {

+        wxZeroMemory(*this);
+

         // hItem member is always valid
         mask = mask_ | TVIF_HANDLE;
         stateMask = stateMask_;
         // hItem member is always valid
         mask = mask_ | TVIF_HANDLE;
         stateMask = stateMask_;


@@ -299,12 +271,43 @@ struct wxTreeViewItem : public TV_ITEM
     }
 };
 
     }
 };
 

+// wxVirutalNode is used in place of a single root when 'hidden' root is
+// specified.
+class wxVirtualNode : public wxTreeViewItem
+{
+public:
+    wxVirtualNode(wxTreeItemData *data)
+        : wxTreeViewItem(TVI_ROOT, 0)
+    {
+        m_data = data;
+    }
+
+    ~wxVirtualNode()
+    {
+        delete m_data;
+    }
+
+    wxTreeItemData *GetData() const { return m_data; }
+    void SetData(wxTreeItemData *data) { delete m_data; m_data = data; }
+
+private:
+    wxTreeItemData *m_data;
+
+    DECLARE_NO_COPY_CLASS(wxVirtualNode)
+};
+

 #ifdef __VISUALC__
 #pragma warning( default : 4097 )
 #endif
 
 #ifdef __VISUALC__
 #pragma warning( default : 4097 )
 #endif
 

+// a macro to get the virtual root, returns NULL if none
+#define GET_VIRTUAL_ROOT() ((wxVirtualNode *)m_pVirtualRoot)
+
+// returns true if the item is the virtual root
+#define IS_VIRTUAL_ROOT(item) (HITEM(item) == TVI_ROOT)
+

 // a class which encapsulates the tree traversal logic: it vists all (unless
 // a class which encapsulates the tree traversal logic: it vists all (unless

-// OnVisit() returns FALSE) items under the given one
+// OnVisit() returns false) items under the given one

 class wxTreeTraversal
 {
 public:
 class wxTreeTraversal
 {
 public:


@@ -314,12 +317,12 @@ public:
     }
 
     // do traverse the tree: visit all items (recursively by default) under the
     }
 
     // do traverse the tree: visit all items (recursively by default) under the

-    // given one; return TRUE if all items were traversed or FALSE if the
-    // traversal was aborted because OnVisit returned FALSE
-    bool DoTraverse(const wxTreeItemId& root, bool recursively = TRUE);
+    // given one; return true if all items were traversed or false if the
+    // traversal was aborted because OnVisit returned false
+    bool DoTraverse(const wxTreeItemId& root, bool recursively = true);

 
     // override this function to do whatever is needed for each item, return
 
     // override this function to do whatever is needed for each item, return

-    // FALSE to stop traversing
+    // false to stop traversing

     virtual bool OnVisit(const wxTreeItemId& item) = 0;
 
 protected:
     virtual bool OnVisit(const wxTreeItemId& item) = 0;
 
 protected:


@@ -329,6 +332,8 @@ private:
     bool Traverse(const wxTreeItemId& root, bool recursively);
 
     const wxTreeCtrl *m_tree;
     bool Traverse(const wxTreeItemId& root, bool recursively);
 
     const wxTreeCtrl *m_tree;

+
+    DECLARE_NO_COPY_CLASS(wxTreeTraversal)

 };
 
 // internal class for getting the selected items
 };
 
 // internal class for getting the selected items


@@ -346,6 +351,12 @@ public:
 
     virtual bool OnVisit(const wxTreeItemId& item)
     {
 
     virtual bool OnVisit(const wxTreeItemId& item)
     {

+        // can't visit a virtual node.
+        if ( (GetTree()->GetRootItem() == item) && (GetTree()->GetWindowStyle() & wxTR_HIDE_ROOT))
+        {
+            return true;
+        }
+

 #if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
         if ( GetTree()->IsItemChecked(item) )
 #else
 #if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
         if ( GetTree()->IsItemChecked(item) )
 #else


@@ -355,13 +366,15 @@ public:
             m_selections.Add(item);
         }
 
             m_selections.Add(item);
         }
 

-        return TRUE;
+        return true;

     }
 
     size_t GetCount() const { return m_selections.GetCount(); }
 
 private:
     wxArrayTreeItemIds& m_selections;
     }
 
     size_t GetCount() const { return m_selections.GetCount(); }
 
 private:
     wxArrayTreeItemIds& m_selections;

+
+    DECLARE_NO_COPY_CLASS(TraverseSelections)

 };
 
 // internal class for counting tree items
 };
 
 // internal class for counting tree items


@@ -382,13 +395,15 @@ public:
     {
         m_count++;
 
     {
         m_count++;
 

-        return TRUE;
+        return true;

     }
 
     size_t GetCount() const { return m_count; }
 
 private:
     size_t m_count;
     }
 
     size_t GetCount() const { return m_count; }
 
 private:
     size_t m_count;

+
+    DECLARE_NO_COPY_CLASS(TraverseCounter)

 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------


@@ -401,11 +416,12 @@ private:
 //
 // There is only one problem with this: when we retrieve the item's data, we
 // don't know whether we get a pointer to wxTreeItemData or
 //
 // There is only one problem with this: when we retrieve the item's data, we
 // don't know whether we get a pointer to wxTreeItemData or

-// wxTreeItemIndirectData. So we have to maintain a list of all items which
-// have indirect data inside the listctrl itself.
+// wxTreeItemIndirectData. So we always set the item id to an invalid value
+// in this class and the code using the client data checks for it and retrieves
+// the real client data in this case.

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-class wxTreeItemIndirectData
+class wxTreeItemIndirectData : public wxTreeItemData

 {
 public:
     // ctor associates this data with the item and the real item data becomes
 {
 public:
     // ctor associates this data with the item and the real item data becomes


@@ -422,10 +438,13 @@ public:
 
         // and set ourselves as the new one
         tree->SetIndirectItemData(item, this);
 
         // and set ourselves as the new one
         tree->SetIndirectItemData(item, this);

+
+        // we must have the invalid value for the item
+        m_pItem = 0l;

     }
 
     // dtor deletes the associated data as well
     }
 
     // dtor deletes the associated data as well

-    ~wxTreeItemIndirectData() { delete m_data; }
+    virtual ~wxTreeItemIndirectData() { delete m_data; }

 
     // accessors
         // get the real data associated with the item
 
     // accessors
         // get the real data associated with the item


@@ -444,25 +463,111 @@ private:
     // all the images associated with the item
     int m_images[wxTreeItemIcon_Max];
 
     // all the images associated with the item
     int m_images[wxTreeItemIcon_Max];
 

+    // the real client data

     wxTreeItemData *m_data;
     wxTreeItemData *m_data;

+
+    DECLARE_NO_COPY_CLASS(wxTreeItemIndirectData)

 };
 
 // ----------------------------------------------------------------------------
 // wxWin macros
 // ----------------------------------------------------------------------------
 
 };
 
 // ----------------------------------------------------------------------------
 // wxWin macros
 // ----------------------------------------------------------------------------
 

+#if wxUSE_EXTENDED_RTTI
+WX_DEFINE_FLAGS( wxTreeCtrlStyle )
+
+wxBEGIN_FLAGS( wxTreeCtrlStyle )
+    // new style border flags, we put them first to
+    // use them for streaming out
+    wxFLAGS_MEMBER(wxBORDER_SIMPLE)
+    wxFLAGS_MEMBER(wxBORDER_SUNKEN)
+    wxFLAGS_MEMBER(wxBORDER_DOUBLE)
+    wxFLAGS_MEMBER(wxBORDER_RAISED)
+    wxFLAGS_MEMBER(wxBORDER_STATIC)
+    wxFLAGS_MEMBER(wxBORDER_NONE)
+
+    // old style border flags
+    wxFLAGS_MEMBER(wxSIMPLE_BORDER)
+    wxFLAGS_MEMBER(wxSUNKEN_BORDER)
+    wxFLAGS_MEMBER(wxDOUBLE_BORDER)
+    wxFLAGS_MEMBER(wxRAISED_BORDER)
+    wxFLAGS_MEMBER(wxSTATIC_BORDER)
+    wxFLAGS_MEMBER(wxBORDER)
+
+    // standard window styles
+    wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
+    wxFLAGS_MEMBER(wxCLIP_CHILDREN)
+    wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
+    wxFLAGS_MEMBER(wxWANTS_CHARS)
+    wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
+    wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
+    wxFLAGS_MEMBER(wxVSCROLL)
+    wxFLAGS_MEMBER(wxHSCROLL)
+
+    wxFLAGS_MEMBER(wxTR_EDIT_LABELS)
+    wxFLAGS_MEMBER(wxTR_NO_BUTTONS)
+    wxFLAGS_MEMBER(wxTR_HAS_BUTTONS)
+    wxFLAGS_MEMBER(wxTR_TWIST_BUTTONS)
+    wxFLAGS_MEMBER(wxTR_NO_LINES)
+    wxFLAGS_MEMBER(wxTR_FULL_ROW_HIGHLIGHT)
+    wxFLAGS_MEMBER(wxTR_LINES_AT_ROOT)
+    wxFLAGS_MEMBER(wxTR_HIDE_ROOT)
+    wxFLAGS_MEMBER(wxTR_ROW_LINES)
+    wxFLAGS_MEMBER(wxTR_HAS_VARIABLE_ROW_HEIGHT)
+    wxFLAGS_MEMBER(wxTR_SINGLE)
+    wxFLAGS_MEMBER(wxTR_MULTIPLE)
+    wxFLAGS_MEMBER(wxTR_EXTENDED)
+    wxFLAGS_MEMBER(wxTR_DEFAULT_STYLE)
+
+wxEND_FLAGS( wxTreeCtrlStyle )
+
+IMPLEMENT_DYNAMIC_CLASS_XTI(wxTreeCtrl, wxControl,"wx/treectrl.h")
+
+wxBEGIN_PROPERTIES_TABLE(wxTreeCtrl)
+    wxEVENT_PROPERTY( TextUpdated , wxEVT_COMMAND_TEXT_UPDATED , wxCommandEvent )
+    wxEVENT_RANGE_PROPERTY( TreeEvent , wxEVT_COMMAND_TREE_BEGIN_DRAG , wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK , wxTreeEvent )
+    wxPROPERTY_FLAGS( WindowStyle , wxTreeCtrlStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
+wxEND_PROPERTIES_TABLE()
+
+wxBEGIN_HANDLERS_TABLE(wxTreeCtrl)
+wxEND_HANDLERS_TABLE()
+
+wxCONSTRUCTOR_5( wxTreeCtrl , wxWindow* , Parent , wxWindowID , Id , wxPoint , Position , wxSize , Size , long , WindowStyle )
+#else

 IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxControl)
 IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxControl)

+#endif

 
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------

-// variables
+// constants

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-// handy table for sending events
-static wxEventType g_events[2][2] =
+// indices in gs_expandEvents table below
+enum
+{
+    IDX_COLLAPSE,
+    IDX_EXPAND,
+    IDX_WHAT_MAX
+};
+
+enum
+{
+    IDX_DONE,
+    IDX_DOING,
+    IDX_HOW_MAX
+};
+
+// handy table for sending events - it has to be initialized during run-time
+// now so can't be const any more
+static /* const */ wxEventType gs_expandEvents[IDX_WHAT_MAX][IDX_HOW_MAX];
+
+/*
+   but logically it's a const table with the following entries:
+=

 {
     { wxEVT_COMMAND_TREE_ITEM_COLLAPSED, wxEVT_COMMAND_TREE_ITEM_COLLAPSING },
     { wxEVT_COMMAND_TREE_ITEM_EXPANDED,  wxEVT_COMMAND_TREE_ITEM_EXPANDING  }
 };
 {
     { wxEVT_COMMAND_TREE_ITEM_COLLAPSED, wxEVT_COMMAND_TREE_ITEM_COLLAPSING },
     { wxEVT_COMMAND_TREE_ITEM_EXPANDED,  wxEVT_COMMAND_TREE_ITEM_EXPANDING  }
 };

+*/

 
 // ============================================================================
 // implementation
 
 // ============================================================================
 // implementation


@@ -475,28 +580,28 @@ static wxEventType g_events[2][2] =
 bool wxTreeTraversal::DoTraverse(const wxTreeItemId& root, bool recursively)
 {
     if ( !OnVisit(root) )
 bool wxTreeTraversal::DoTraverse(const wxTreeItemId& root, bool recursively)
 {
     if ( !OnVisit(root) )

-        return FALSE;
+        return false;

 
     return Traverse(root, recursively);
 }
 
 bool wxTreeTraversal::Traverse(const wxTreeItemId& root, bool recursively)
 {
 
     return Traverse(root, recursively);
 }
 
 bool wxTreeTraversal::Traverse(const wxTreeItemId& root, bool recursively)
 {

-    long cookie;
+    wxTreeItemIdValue cookie;

     wxTreeItemId child = m_tree->GetFirstChild(root, cookie);
     while ( child.IsOk() )
     {
         // depth first traversal
     wxTreeItemId child = m_tree->GetFirstChild(root, cookie);
     while ( child.IsOk() )
     {
         // depth first traversal

-        if ( recursively && !Traverse(child, TRUE) )
-            return FALSE;
+        if ( recursively && !Traverse(child, true) )
+            return false;

 
         if ( !OnVisit(child) )
 
         if ( !OnVisit(child) )

-            return FALSE;
+            return false;

 
         child = m_tree->GetNextChild(root, cookie);
     }
 
 
         child = m_tree->GetNextChild(root, cookie);
     }
 

-    return TRUE;
+    return true;

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


@@ -507,19 +612,18 @@ void wxTreeCtrl::Init()
 {
     m_imageListNormal = NULL;
     m_imageListState = NULL;
 {
     m_imageListNormal = NULL;
     m_imageListState = NULL;

-    m_ownsImageListNormal = m_ownsImageListState = FALSE;
+    m_ownsImageListNormal = m_ownsImageListState = false;

     m_textCtrl = NULL;
     m_textCtrl = NULL;

-    m_hasAnyAttr = FALSE;
+    m_hasAnyAttr = false;

     m_dragImage = NULL;
     m_dragImage = NULL;

-    m_htSelStart = 0;
+    m_pVirtualRoot = NULL;

 
 

-    // Initialize static array of events, because with the new event system,
-    // they may not be initialized yet.
-
-    g_events[0][0] = wxEVT_COMMAND_TREE_ITEM_COLLAPSED;
-    g_events[0][1] = wxEVT_COMMAND_TREE_ITEM_COLLAPSING;
-    g_events[1][0] = wxEVT_COMMAND_TREE_ITEM_EXPANDED;
-    g_events[1][1] = wxEVT_COMMAND_TREE_ITEM_EXPANDING;
+    // initialize the global array of events now as it can't be done statically
+    // with the wxEVT_XXX values being allocated during run-time only
+    gs_expandEvents[IDX_COLLAPSE][IDX_DONE] = wxEVT_COMMAND_TREE_ITEM_COLLAPSED;
+    gs_expandEvents[IDX_COLLAPSE][IDX_DOING] = wxEVT_COMMAND_TREE_ITEM_COLLAPSING;
+    gs_expandEvents[IDX_EXPAND][IDX_DONE] = wxEVT_COMMAND_TREE_ITEM_EXPANDED;
+    gs_expandEvents[IDX_EXPAND][IDX_DOING] = wxEVT_COMMAND_TREE_ITEM_EXPANDING;

 }
 
 bool wxTreeCtrl::Create(wxWindow *parent,
 }
 
 bool wxTreeCtrl::Create(wxWindow *parent,


@@ -532,14 +636,15 @@ bool wxTreeCtrl::Create(wxWindow *parent,
 {
     Init();
 
 {
     Init();
 

-    if ( !CreateControl(parent, id, pos, size, style, validator, name) )
-        return FALSE;
+    if ( (style & wxBORDER_MASK) == wxBORDER_DEFAULT )
+        style |= wxBORDER_SUNKEN;

 
 

-    DWORD wstyle = WS_VISIBLE | WS_CHILD | WS_TABSTOP |
-                   TVS_SHOWSELALWAYS;
+    if ( !CreateControl(parent, id, pos, size, style, validator, name) )
+        return false;

 
 

-    if ( m_windowStyle & wxCLIP_SIBLINGS )
-        wstyle |= WS_CLIPSIBLINGS;
+    DWORD exStyle = 0;
+    DWORD wstyle = MSWGetStyle(m_windowStyle, & exStyle);
+    wstyle |= WS_TABSTOP | TVS_SHOWSELALWAYS;

 
     if ((m_windowStyle & wxTR_NO_LINES) == 0)
         wstyle |= TVS_HASLINES;
 
     if ((m_windowStyle & wxTR_NO_LINES) == 0)
         wstyle |= TVS_HASLINES;


@@ -551,14 +656,13 @@ bool wxTreeCtrl::Create(wxWindow *parent,
 
     if ( m_windowStyle & wxTR_LINES_AT_ROOT )
         wstyle |= TVS_LINESATROOT;
 
     if ( m_windowStyle & wxTR_LINES_AT_ROOT )
         wstyle |= TVS_LINESATROOT;

-    
+

     if ( m_windowStyle & wxTR_FULL_ROW_HIGHLIGHT )
     if ( m_windowStyle & wxTR_FULL_ROW_HIGHLIGHT )

-    {    
+    {

         if ( wxTheApp->GetComCtl32Version() >= 471 )
             wstyle |= TVS_FULLROWSELECT;
     }
 
         if ( wxTheApp->GetComCtl32Version() >= 471 )
             wstyle |= TVS_FULLROWSELECT;
     }
 

-

     // using TVS_CHECKBOXES for emulation of a multiselection tree control
     // doesn't work without the new enough headers
 #if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE && \
     // using TVS_CHECKBOXES for emulation of a multiselection tree control
     // doesn't work without the new enough headers
 #if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE && \


@@ -573,15 +677,20 @@ bool wxTreeCtrl::Create(wxWindow *parent,
         wstyle |= TVS_CHECKBOXES;
 #endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
 
         wstyle |= TVS_CHECKBOXES;
 #endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
 

+#ifndef __WXWINCE__
+    // Need so that TVN_GETINFOTIP messages will be sent
+    wstyle |= TVS_INFOTIP;
+#endif
+

     // Create the tree control.
     if ( !MSWCreateControl(WC_TREEVIEW, wstyle) )
     // Create the tree control.
     if ( !MSWCreateControl(WC_TREEVIEW, wstyle) )

-        return FALSE;
+        return false;

 
 #if wxUSE_COMCTL32_SAFELY
 
 #if wxUSE_COMCTL32_SAFELY

-    wxWindow::SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
+    wxWindow::SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));

     wxWindow::SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
 #elif 1
     wxWindow::SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
 #elif 1

-    SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
+    SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));

     SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
 #else
     // This works around a bug in the Windows tree control whereby for some versions
     SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
 #else
     // This works around a bug in the Windows tree control whereby for some versions


@@ -590,7 +699,7 @@ bool wxTreeCtrl::Create(wxWindow *parent,
     // THIS FIX NOW REVERTED since it caused problems on _other_ systems.
     // Assume the user has an updated comctl32.dll.
     ::SendMessage(GetHwnd(), TVM_SETBKCOLOR, 0,-1);
     // THIS FIX NOW REVERTED since it caused problems on _other_ systems.
     // Assume the user has an updated comctl32.dll.
     ::SendMessage(GetHwnd(), TVM_SETBKCOLOR, 0,-1);

-    wxWindow::SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
+    wxWindow::SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));

     SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
 #endif
 
     SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
 #endif
 


@@ -609,7 +718,7 @@ bool wxTreeCtrl::Create(wxWindow *parent,
         // create a mono bitmap of the standard size
         int x = GetSystemMetrics(SM_CXMENUCHECK);
         int y = GetSystemMetrics(SM_CYMENUCHECK);
         // create a mono bitmap of the standard size
         int x = GetSystemMetrics(SM_CXMENUCHECK);
         int y = GetSystemMetrics(SM_CYMENUCHECK);

-        wxImageList imagelistCheckboxes(x, y, FALSE, 2);
+        wxImageList imagelistCheckboxes(x, y, false, 2);

         HBITMAP hbmpCheck = CreateBitmap(x, y,   // bitmap size
                                          1,      // # of color planes
                                          1,      // # bits needed for one pixel
         HBITMAP hbmpCheck = CreateBitmap(x, y,   // bitmap size
                                          1,      // # of color planes
                                          1,      // # bits needed for one pixel


@@ -648,7 +757,9 @@ bool wxTreeCtrl::Create(wxWindow *parent,
 
     SetSize(pos.x, pos.y, size.x, size.y);
 
 
     SetSize(pos.x, pos.y, size.x, size.y);
 

-    return TRUE;
+    wxSetCCUnicodeFormat(GetHwnd());
+
+    return true;

 }
 
 wxTreeCtrl::~wxTreeCtrl()
 }
 
 wxTreeCtrl::~wxTreeCtrl()


@@ -656,18 +767,16 @@ wxTreeCtrl::~wxTreeCtrl()
     // delete any attributes
     if ( m_hasAnyAttr )
     {
     // delete any attributes
     if ( m_hasAnyAttr )
     {

-        for ( wxNode *node = m_attrs.Next(); node; node = m_attrs.Next() )
-        {
-            delete (wxTreeItemAttr *)node->Data();
-        }
+        WX_CLEAR_HASH_MAP(wxMapTreeAttr, m_attrs);

 
         // prevent TVN_DELETEITEM handler from deleting the attributes again!
 
         // prevent TVN_DELETEITEM handler from deleting the attributes again!

-        m_hasAnyAttr = FALSE;
+        m_hasAnyAttr = false;

     }
 
     DeleteTextCtrl();
 
     // delete user data to prevent memory leaks
     }
 
     DeleteTextCtrl();
 
     // delete user data to prevent memory leaks

+    // also deletes hidden root node storage.

     DeleteAllItems();
 
     if (m_ownsImageListNormal) delete m_imageListNormal;
     DeleteAllItems();
 
     if (m_ownsImageListNormal) delete m_imageListNormal;


@@ -678,18 +787,33 @@ wxTreeCtrl::~wxTreeCtrl()
 // accessors
 // ----------------------------------------------------------------------------
 
 // accessors
 // ----------------------------------------------------------------------------
 

+/* static */ wxVisualAttributes
+wxTreeCtrl::GetClassDefaultAttributes(wxWindowVariant variant)
+{
+    wxVisualAttributes attrs = GetCompositeControlsDefaultAttributes(variant);
+
+    // common controls have their own default font
+    attrs.font = wxGetCCDefaultFont();
+
+    return attrs;
+}
+
+

 // simple wrappers which add error checking in debug mode
 
 bool wxTreeCtrl::DoGetItem(wxTreeViewItem* tvItem) const
 {
 // simple wrappers which add error checking in debug mode
 
 bool wxTreeCtrl::DoGetItem(wxTreeViewItem* tvItem) const
 {

+    wxCHECK_MSG( tvItem->hItem != TVI_ROOT, false,
+                 _T("can't retrieve virtual root item") );
+

     if ( !TreeView_GetItem(GetHwnd(), tvItem) )
     {
         wxLogLastError(wxT("TreeView_GetItem"));
 
     if ( !TreeView_GetItem(GetHwnd(), tvItem) )
     {
         wxLogLastError(wxT("TreeView_GetItem"));
 

-        return FALSE;
+        return false;

     }
 
     }
 

-    return TRUE;
+    return true;

 }
 
 void wxTreeCtrl::DoSetItem(wxTreeViewItem* tvItem)
 }
 
 void wxTreeCtrl::DoSetItem(wxTreeViewItem* tvItem)


@@ -722,7 +846,7 @@ wxImageList *wxTreeCtrl::GetImageList() const
 
 wxImageList *wxTreeCtrl::GetStateImageList() const
 {
 
 wxImageList *wxTreeCtrl::GetStateImageList() const
 {

-    return m_imageListNormal;
+    return m_imageListState;

 }
 
 void wxTreeCtrl::SetAnyImageList(wxImageList *imageList, int which)
 }
 
 void wxTreeCtrl::SetAnyImageList(wxImageList *imageList, int which)


@@ -735,28 +859,30 @@ void wxTreeCtrl::SetAnyImageList(wxImageList *imageList, int which)
 
 void wxTreeCtrl::SetImageList(wxImageList *imageList)
 {
 
 void wxTreeCtrl::SetImageList(wxImageList *imageList)
 {

-    if (m_ownsImageListNormal) delete m_imageListNormal;
+    if (m_ownsImageListNormal)
+        delete m_imageListNormal;
+

     SetAnyImageList(m_imageListNormal = imageList, TVSIL_NORMAL);
     SetAnyImageList(m_imageListNormal = imageList, TVSIL_NORMAL);

-    m_ownsImageListNormal = FALSE;
+    m_ownsImageListNormal = false;

 }
 
 void wxTreeCtrl::SetStateImageList(wxImageList *imageList)
 {
     if (m_ownsImageListState) delete m_imageListState;
     SetAnyImageList(m_imageListState = imageList, TVSIL_STATE);
 }
 
 void wxTreeCtrl::SetStateImageList(wxImageList *imageList)
 {
     if (m_ownsImageListState) delete m_imageListState;
     SetAnyImageList(m_imageListState = imageList, TVSIL_STATE);

-    m_ownsImageListState = FALSE;
+    m_ownsImageListState = false;

 }
 
 void wxTreeCtrl::AssignImageList(wxImageList *imageList)
 {
     SetImageList(imageList);
 }
 
 void wxTreeCtrl::AssignImageList(wxImageList *imageList)
 {
     SetImageList(imageList);

-    m_ownsImageListNormal = TRUE;
+    m_ownsImageListNormal = true;

 }
 
 void wxTreeCtrl::AssignStateImageList(wxImageList *imageList)
 {
     SetStateImageList(imageList);
 }
 
 void wxTreeCtrl::AssignStateImageList(wxImageList *imageList)
 {
     SetStateImageList(imageList);

-    m_ownsImageListState = TRUE;
+    m_ownsImageListState = true;

 }
 
 size_t wxTreeCtrl::GetChildrenCount(const wxTreeItemId& item,
 }
 
 size_t wxTreeCtrl::GetChildrenCount(const wxTreeItemId& item,


@@ -775,24 +901,24 @@ bool wxTreeCtrl::SetBackgroundColour(const wxColour &colour)
 {
 #if !wxUSE_COMCTL32_SAFELY
     if ( !wxWindowBase::SetBackgroundColour(colour) )
 {
 #if !wxUSE_COMCTL32_SAFELY
     if ( !wxWindowBase::SetBackgroundColour(colour) )

-        return FALSE;
+        return false;

 
     SendMessage(GetHwnd(), TVM_SETBKCOLOR, 0, colour.GetPixel());
 #endif
 
 
     SendMessage(GetHwnd(), TVM_SETBKCOLOR, 0, colour.GetPixel());
 #endif
 

-    return TRUE;
+    return true;

 }
 
 bool wxTreeCtrl::SetForegroundColour(const wxColour &colour)
 {
 #if !wxUSE_COMCTL32_SAFELY
     if ( !wxWindowBase::SetForegroundColour(colour) )
 }
 
 bool wxTreeCtrl::SetForegroundColour(const wxColour &colour)
 {
 #if !wxUSE_COMCTL32_SAFELY
     if ( !wxWindowBase::SetForegroundColour(colour) )

-        return FALSE;
+        return false;

 
     SendMessage(GetHwnd(), TVM_SETTEXTCOLOR, 0, colour.GetPixel());
 #endif
 
 
     SendMessage(GetHwnd(), TVM_SETTEXTCOLOR, 0, colour.GetPixel());
 #endif
 

-    return TRUE;
+    return true;

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


@@ -817,9 +943,26 @@ wxString wxTreeCtrl::GetItemText(const wxTreeItemId& item) const
 
 void wxTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text)
 {
 
 void wxTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text)
 {

+    if ( IS_VIRTUAL_ROOT(item) )
+        return;
+

     wxTreeViewItem tvItem(item, TVIF_TEXT);
     tvItem.pszText = (wxChar *)text.c_str();  // conversion is ok
     DoSetItem(&tvItem);
     wxTreeViewItem tvItem(item, TVIF_TEXT);
     tvItem.pszText = (wxChar *)text.c_str();  // conversion is ok
     DoSetItem(&tvItem);

+
+    // when setting the text of the item being edited, the text control should
+    // be updated to reflect the new text as well, otherwise calling
+    // SetItemText() in the OnBeginLabelEdit() handler doesn't have any effect
+    //
+    // don't use GetEditControl() here because m_textCtrl is not set yet
+    HWND hwndEdit = TreeView_GetEditControl(GetHwnd());
+    if ( hwndEdit )
+    {
+        if ( item == GetSelection() )
+        {
+            ::SetWindowText(hwndEdit, text);
+        }
+    }

 }
 
 int wxTreeCtrl::DoGetItemImageFromData(const wxTreeItemId& item,
 }
 
 int wxTreeCtrl::DoGetItemImageFromData(const wxTreeItemId& item,


@@ -875,6 +1018,12 @@ void wxTreeCtrl::DoSetItemImages(const wxTreeItemId& item,
 int wxTreeCtrl::GetItemImage(const wxTreeItemId& item,
                              wxTreeItemIcon which) const
 {
 int wxTreeCtrl::GetItemImage(const wxTreeItemId& item,
                              wxTreeItemIcon which) const
 {

+    if ( (HITEM(item) == TVI_ROOT) && (m_windowStyle & wxTR_HIDE_ROOT) )
+    {
+        // TODO: Maybe a hidden root can still provide images?
+        return -1;
+    }
+

     if ( HasIndirectData(item) )
     {
         return DoGetItemImageFromData(item, which);
     if ( HasIndirectData(item) )
     {
         return DoGetItemImageFromData(item, which);


@@ -908,15 +1057,35 @@ int wxTreeCtrl::GetItemImage(const wxTreeItemId& item,
 void wxTreeCtrl::SetItemImage(const wxTreeItemId& item, int image,
                               wxTreeItemIcon which)
 {
 void wxTreeCtrl::SetItemImage(const wxTreeItemId& item, int image,
                               wxTreeItemIcon which)
 {

-    int imageNormal, imageSel;
+    if ( IS_VIRTUAL_ROOT(item) )
+    {
+        // TODO: Maybe a hidden root can still store images?
+        return;
+    }
+
+    int imageNormal,
+        imageSel;
+

     switch ( which )
     {
         default:
             wxFAIL_MSG( wxT("unknown tree item image type") );
     switch ( which )
     {
         default:
             wxFAIL_MSG( wxT("unknown tree item image type") );

+            // fall through

 
         case wxTreeItemIcon_Normal:
 
         case wxTreeItemIcon_Normal:

-            imageNormal = image;
-            imageSel = GetItemSelectedImage(item);
+            {
+                const int imageNormalOld = GetItemImage(item);
+                const int imageSelOld =
+                    GetItemImage(item, wxTreeItemIcon_Selected);
+
+                // always set the normal image
+                imageNormal = image;
+
+                // if the selected and normal images were the same, they should
+                // be the same after the update, otherwise leave the selected
+                // image as it was
+                imageSel = imageNormalOld == imageSelOld ? image : imageSelOld;
+            }

             break;
 
         case wxTreeItemIcon_Selected:
             break;
 
         case wxTreeItemIcon_Selected:


@@ -932,7 +1101,7 @@ void wxTreeCtrl::SetItemImage(const wxTreeItemId& item, int image,
                 // the wxTreeItemIndirectData GetItemXXXImage() will use it to
                 // get the images
                 imageNormal = GetItemImage(item);
                 // the wxTreeItemIndirectData GetItemXXXImage() will use it to
                 // get the images
                 imageNormal = GetItemImage(item);

-                imageSel = GetItemSelectedImage(item);
+                imageSel = GetItemImage(item, wxTreeItemIcon_Selected);

 
                 // if it doesn't have it yet, add it
                 wxTreeItemIndirectData *data = new
 
                 // if it doesn't have it yet, add it
                 wxTreeItemIndirectData *data = new


@@ -961,23 +1130,35 @@ void wxTreeCtrl::SetItemImage(const wxTreeItemId& item, int image,
 wxTreeItemData *wxTreeCtrl::GetItemData(const wxTreeItemId& item) const
 {
     wxTreeViewItem tvItem(item, TVIF_PARAM);
 wxTreeItemData *wxTreeCtrl::GetItemData(const wxTreeItemId& item) const
 {
     wxTreeViewItem tvItem(item, TVIF_PARAM);

-    if ( !DoGetItem(&tvItem) )
+
+    // Hidden root may have data.
+    if ( IS_VIRTUAL_ROOT(item) )

     {
     {

-        return NULL;
+        return GET_VIRTUAL_ROOT()->GetData();

     }
 
     }
 

-    if ( HasIndirectData(item) )
+    // Visible node.
+    if ( !DoGetItem(&tvItem) )

     {
     {

-        return ((wxTreeItemIndirectData *)tvItem.lParam)->GetData();
+        return NULL;

     }
     }

-    else
+
+    wxTreeItemData *data = (wxTreeItemData *)tvItem.lParam;
+    if ( IsDataIndirect(data) )

     {
     {

-        return (wxTreeItemData *)tvItem.lParam;
+        data = ((wxTreeItemIndirectData *)data)->GetData();

     }
     }

+
+    return data;

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

+    if ( IS_VIRTUAL_ROOT(item) )
+    {
+        GET_VIRTUAL_ROOT()->SetData(data);
+    }
+

     // first, associate this piece of data with this item
     if ( data )
     {
     // first, associate this piece of data with this item
     if ( data )
     {


@@ -1013,18 +1194,28 @@ void wxTreeCtrl::SetIndirectItemData(const wxTreeItemId& item,
     // wxTreeItemIndirectData as well
     wxASSERT_MSG( !HasIndirectData(item), wxT("setting indirect data twice?") );
 
     // wxTreeItemIndirectData as well
     wxASSERT_MSG( !HasIndirectData(item), wxT("setting indirect data twice?") );
 

-    SetItemData(item, (wxTreeItemData *)data);
-
-    m_itemsWithIndirectData.Add(item);
+    SetItemData(item, data);

 }
 
 bool wxTreeCtrl::HasIndirectData(const wxTreeItemId& item) const
 {
 }
 
 bool wxTreeCtrl::HasIndirectData(const wxTreeItemId& item) const
 {

-    return m_itemsWithIndirectData.Index(item) != wxNOT_FOUND;
+    // query the item itself
+    wxTreeViewItem tvItem(item, TVIF_PARAM);
+    if ( !DoGetItem(&tvItem) )
+    {
+        return false;
+    }
+
+    wxTreeItemData *data = (wxTreeItemData *)tvItem.lParam;
+
+    return data && IsDataIndirect(data);

 }
 
 void wxTreeCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
 {
 }
 
 void wxTreeCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
 {

+    if ( IS_VIRTUAL_ROOT(item) )
+        return;
+

     wxTreeViewItem tvItem(item, TVIF_CHILDREN);
     tvItem.cChildren = (int)has;
     DoSetItem(&tvItem);
     wxTreeViewItem tvItem(item, TVIF_CHILDREN);
     tvItem.cChildren = (int)has;
     DoSetItem(&tvItem);


@@ -1032,6 +1223,9 @@ void wxTreeCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
 
 void wxTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
 {
 
 void wxTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
 {

+    if ( IS_VIRTUAL_ROOT(item) )
+        return;
+

     wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_BOLD);
     tvItem.state = bold ? TVIS_BOLD : 0;
     DoSetItem(&tvItem);
     wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_BOLD);
     tvItem.state = bold ? TVIS_BOLD : 0;
     DoSetItem(&tvItem);


@@ -1039,6 +1233,9 @@ void wxTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
 
 void wxTreeCtrl::SetItemDropHighlight(const wxTreeItemId& item, bool highlight)
 {
 
 void wxTreeCtrl::SetItemDropHighlight(const wxTreeItemId& item, bool highlight)
 {

+    if ( IS_VIRTUAL_ROOT(item) )
+        return;
+

     wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_DROPHILITED);
     tvItem.state = highlight ? TVIS_DROPHILITED : 0;
     DoSetItem(&tvItem);
     wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_DROPHILITED);
     tvItem.state = highlight ? TVIS_DROPHILITED : 0;
     DoSetItem(&tvItem);


@@ -1046,6 +1243,9 @@ void wxTreeCtrl::SetItemDropHighlight(const wxTreeItemId& item, bool highlight)
 
 void wxTreeCtrl::RefreshItem(const wxTreeItemId& item)
 {
 
 void wxTreeCtrl::RefreshItem(const wxTreeItemId& item)
 {

+    if ( IS_VIRTUAL_ROOT(item) )
+        return;
+

     wxRect rect;
     if ( GetBoundingRect(item, rect) )
     {
     wxRect rect;
     if ( GetBoundingRect(item, rect) )
     {


@@ -1053,17 +1253,42 @@ void wxTreeCtrl::RefreshItem(const wxTreeItemId& item)
     }
 }
 
     }
 }
 

+wxColour wxTreeCtrl::GetItemTextColour(const wxTreeItemId& item) const
+{
+    wxMapTreeAttr::const_iterator it = m_attrs.find(item.m_pItem);
+
+    return it == m_attrs.end() ? wxNullColour : it->second->GetTextColour();
+}
+
+wxColour wxTreeCtrl::GetItemBackgroundColour(const wxTreeItemId& item) const
+{
+    wxMapTreeAttr::const_iterator it = m_attrs.find(item.m_pItem);
+
+    return it == m_attrs.end() ? wxNullColour : it->second->GetBackgroundColour();
+}
+
+wxFont wxTreeCtrl::GetItemFont(const wxTreeItemId& item) const
+{
+    wxMapTreeAttr::const_iterator it = m_attrs.find(item.m_pItem);
+
+    return it == m_attrs.end() ? wxNullFont : it->second->GetFont();
+}
+

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

-    m_hasAnyAttr = TRUE;
-
-    long id = (long)(WXHTREEITEM)item;
-    wxTreeItemAttr *attr = (wxTreeItemAttr *)m_attrs.Get(id);
-    if ( !attr )
+    wxTreeItemAttr *attr;
+    wxMapTreeAttr::iterator it = m_attrs.find(item.m_pItem);
+    if ( it == m_attrs.end() )

     {
     {

+        m_hasAnyAttr = true;
+
+        m_attrs[item.m_pItem] =

         attr = new wxTreeItemAttr;
         attr = new wxTreeItemAttr;

-        m_attrs.Put(id, (wxObject *)attr);
+    }
+    else
+    {
+        attr = it->second;

     }
 
     attr->SetTextColour(col);
     }
 
     attr->SetTextColour(col);


@@ -1074,14 +1299,18 @@ void wxTreeCtrl::SetItemTextColour(const wxTreeItemId& item,
 void wxTreeCtrl::SetItemBackgroundColour(const wxTreeItemId& item,
                                          const wxColour& col)
 {
 void wxTreeCtrl::SetItemBackgroundColour(const wxTreeItemId& item,
                                          const wxColour& col)
 {

-    m_hasAnyAttr = TRUE;
-
-    long id = (long)(WXHTREEITEM)item;
-    wxTreeItemAttr *attr = (wxTreeItemAttr *)m_attrs.Get(id);
-    if ( !attr )
+    wxTreeItemAttr *attr;
+    wxMapTreeAttr::iterator it = m_attrs.find(item.m_pItem);
+    if ( it == m_attrs.end() )

     {
     {

+        m_hasAnyAttr = true;
+
+        m_attrs[item.m_pItem] =

         attr = new wxTreeItemAttr;
         attr = new wxTreeItemAttr;

-        m_attrs.Put(id, (wxObject *)attr);
+    }
+    else // already in the hash
+    {
+        attr = it->second;

     }
 
     attr->SetBackgroundColour(col);
     }
 
     attr->SetBackgroundColour(col);


@@ -1091,14 +1320,18 @@ void wxTreeCtrl::SetItemBackgroundColour(const wxTreeItemId& item,
 
 void wxTreeCtrl::SetItemFont(const wxTreeItemId& item, const wxFont& font)
 {
 
 void wxTreeCtrl::SetItemFont(const wxTreeItemId& item, const wxFont& font)
 {

-    m_hasAnyAttr = TRUE;
-
-    long id = (long)(WXHTREEITEM)item;
-    wxTreeItemAttr *attr = (wxTreeItemAttr *)m_attrs.Get(id);
-    if ( !attr )
+    wxTreeItemAttr *attr;
+    wxMapTreeAttr::iterator it = m_attrs.find(item.m_pItem);
+    if ( it == m_attrs.end() )

     {
     {

+        m_hasAnyAttr = true;
+
+        m_attrs[item.m_pItem] =

         attr = new wxTreeItemAttr;
         attr = new wxTreeItemAttr;

-        m_attrs.Put(id, (wxObject *)attr);
+    }
+    else // already in the hash
+    {
+        attr = it->second;

     }
 
     attr->SetFont(font);
     }
 
     attr->SetFont(font);


@@ -1112,15 +1345,31 @@ void wxTreeCtrl::SetItemFont(const wxTreeItemId& item, const wxFont& font)
 
 bool wxTreeCtrl::IsVisible(const wxTreeItemId& item) const
 {
 
 bool wxTreeCtrl::IsVisible(const wxTreeItemId& item) const
 {

+    if ( item == wxTreeItemId(TVI_ROOT) )
+    {
+        // virtual (hidden) root is never visible
+        return false;
+    }
+

     // Bug in Gnu-Win32 headers, so don't use the macro TreeView_GetItemRect
     RECT rect;
 
     // this ugliness comes directly from MSDN - it *is* the correct way to pass
     // the HTREEITEM with TVM_GETITEMRECT
     // Bug in Gnu-Win32 headers, so don't use the macro TreeView_GetItemRect
     RECT rect;
 
     // this ugliness comes directly from MSDN - it *is* the correct way to pass
     // the HTREEITEM with TVM_GETITEMRECT

-    *(WXHTREEITEM *)&rect = (WXHTREEITEM)item;
+    *(HTREEITEM *)&rect = HITEM(item);

 
 

-    // FALSE means get item rect for the whole item, not only text
-    return SendMessage(GetHwnd(), TVM_GETITEMRECT, FALSE, (LPARAM)&rect) != 0;
+    // true means to get rect for just the text, not the whole line
+    if ( !::SendMessage(GetHwnd(), TVM_GETITEMRECT, true, (LPARAM)&rect) )
+    {
+        // if TVM_GETITEMRECT returned false, then the item is definitely not
+        // visible (because its parent is not expanded)
+        return false;
+    }
+
+    // however if it returned true, the item might still be outside the
+    // currently visible part of the tree, test for it (notice that partly
+    // visible means visible here)
+    return rect.bottom > 0 && rect.top < GetClientSize().y;

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


@@ -1164,45 +1413,91 @@ bool wxTreeCtrl::IsBold(const wxTreeItemId& item) const
 
 wxTreeItemId wxTreeCtrl::GetRootItem() const
 {
 
 wxTreeItemId wxTreeCtrl::GetRootItem() const
 {

-    return wxTreeItemId((WXHTREEITEM) TreeView_GetRoot(GetHwnd()));
+    // Root may be real (visible) or virtual (hidden).
+    if ( GET_VIRTUAL_ROOT() )
+        return TVI_ROOT;
+
+    return wxTreeItemId(TreeView_GetRoot(GetHwnd()));

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

-    wxCHECK_MSG( !(m_windowStyle & wxTR_MULTIPLE), (long)(WXHTREEITEM)0,
+    wxCHECK_MSG( !(m_windowStyle & wxTR_MULTIPLE), wxTreeItemId(),

                  wxT("this only works with single selection controls") );
 
                  wxT("this only works with single selection controls") );
 

-    return wxTreeItemId((WXHTREEITEM) TreeView_GetSelection(GetHwnd()));
+    return wxTreeItemId(TreeView_GetSelection(GetHwnd()));

 }
 
 }
 

-wxTreeItemId wxTreeCtrl::GetParent(const wxTreeItemId& item) const
+wxTreeItemId wxTreeCtrl::GetItemParent(const wxTreeItemId& item) const

 {
 {

-    return wxTreeItemId((WXHTREEITEM) TreeView_GetParent(GetHwnd(), HITEM(item)));
+    HTREEITEM hItem;
+
+    if ( IS_VIRTUAL_ROOT(item) )
+    {
+        // no parent for the virtual root
+        hItem = 0;
+    }
+    else // normal item
+    {
+        hItem = TreeView_GetParent(GetHwnd(), HITEM(item));
+        if ( !hItem && HasFlag(wxTR_HIDE_ROOT) )
+        {
+            // the top level items should have the virtual root as their parent
+            hItem = TVI_ROOT;
+        }
+    }
+
+    return wxTreeItemId(hItem);

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

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

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

-    _cookie = (long)TreeView_GetChild(GetHwnd(), HITEM(item));
+    cookie = TreeView_GetChild(GetHwnd(), HITEM(item));
+
+    return wxTreeItemId(cookie);
+}
+
+wxTreeItemId wxTreeCtrl::GetNextChild(const wxTreeItemId& WXUNUSED(item),
+                                      wxTreeItemIdValue& cookie) const
+{
+    wxTreeItemId item(TreeView_GetNextSibling(GetHwnd(),
+                                              HITEM(wxTreeItemId(cookie))));
+    cookie = item.m_pItem;

 
 

-    return wxTreeItemId((WXHTREEITEM)_cookie);
+    return item;
+}
+
+#if WXWIN_COMPATIBILITY_2_4
+
+wxTreeItemId wxTreeCtrl::GetFirstChild(const wxTreeItemId& item,
+                                       long& cookie) const
+{
+    cookie = (long)TreeView_GetChild(GetHwnd(), HITEM(item));
+
+    return wxTreeItemId((void *)cookie);

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

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

 {
 {

-    wxTreeItemId l = wxTreeItemId((WXHTREEITEM)TreeView_GetNextSibling(GetHwnd(),
-                                   HITEM(_cookie)));
-    _cookie = (long)l;
+    wxTreeItemId item(TreeView_GetNextSibling
+                      (
+                        GetHwnd(),
+                        HITEM(wxTreeItemId((void *)cookie)
+                      )));
+    cookie = (long)item.m_pItem;

 
 

-    return l;
+    return item;

 }
 
 }
 

+#endif // WXWIN_COMPATIBILITY_2_4
+

 wxTreeItemId wxTreeCtrl::GetLastChild(const wxTreeItemId& item) const
 {
     // can this be done more efficiently?
 wxTreeItemId wxTreeCtrl::GetLastChild(const wxTreeItemId& item) const
 {
     // can this be done more efficiently?

-    long cookie;
+    wxTreeItemIdValue cookie;

 
     wxTreeItemId childLast,
     child = GetFirstChild(item, cookie);
 
     wxTreeItemId childLast,
     child = GetFirstChild(item, cookie);


@@ -1217,31 +1512,31 @@ wxTreeItemId wxTreeCtrl::GetLastChild(const wxTreeItemId& item) const
 
 wxTreeItemId wxTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
 {
 
 wxTreeItemId wxTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
 {

-    return wxTreeItemId((WXHTREEITEM) TreeView_GetNextSibling(GetHwnd(), HITEM(item)));
+    return wxTreeItemId(TreeView_GetNextSibling(GetHwnd(), HITEM(item)));

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

-    return wxTreeItemId((WXHTREEITEM) TreeView_GetPrevSibling(GetHwnd(), HITEM(item)));
+    return wxTreeItemId(TreeView_GetPrevSibling(GetHwnd(), HITEM(item)));

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

-    return wxTreeItemId((WXHTREEITEM) TreeView_GetFirstVisible(GetHwnd()));
+    return wxTreeItemId(TreeView_GetFirstVisible(GetHwnd()));

 }
 
 wxTreeItemId wxTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
 {
     wxASSERT_MSG( IsVisible(item), wxT("The item you call GetNextVisible() for must be visible itself!"));
 
 }
 
 wxTreeItemId wxTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
 {
     wxASSERT_MSG( IsVisible(item), wxT("The item you call GetNextVisible() for must be visible itself!"));
 

-    return wxTreeItemId((WXHTREEITEM) TreeView_GetNextVisible(GetHwnd(), HITEM(item)));
+    return wxTreeItemId(TreeView_GetNextVisible(GetHwnd(), HITEM(item)));

 }
 
 wxTreeItemId wxTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
 {
     wxASSERT_MSG( IsVisible(item), wxT("The item you call GetPrevVisible() for must be visible itself!"));
 
 }
 
 wxTreeItemId wxTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
 {
     wxASSERT_MSG( IsVisible(item), wxT("The item you call GetPrevVisible() for must be visible itself!"));
 

-    return wxTreeItemId((WXHTREEITEM) TreeView_GetPrevVisible(GetHwnd(), HITEM(item)));
+    return wxTreeItemId(TreeView_GetPrevVisible(GetHwnd(), HITEM(item)));

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


@@ -1263,6 +1558,8 @@ void wxTreeCtrl::SetItemCheck(const wxTreeItemId& item, bool check)
     // receive the desired information.
     wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_STATEIMAGEMASK);
 
     // receive the desired information.
     wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_STATEIMAGEMASK);
 

+    DoGetItem(&tvItem);
+

     // state images are one-based
     tvItem.state = (check ? 2 : 1) << 12;
 
     // state images are one-based
     tvItem.state = (check ? 2 : 1) << 12;
 


@@ -1348,27 +1645,40 @@ wxTreeItemId wxTreeCtrl::DoInsertItem(const wxTreeItemId& parent,
     if ( data != NULL )
     {
         // associate the application tree item with Win32 tree item handle
     if ( data != NULL )
     {
         // associate the application tree item with Win32 tree item handle

-        data->SetId((WXHTREEITEM)id);
+        data->SetId(id);

     }
 
     }
 

-    return wxTreeItemId((WXHTREEITEM)id);
+    return wxTreeItemId(id);

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

+#if WXWIN_COMPATIBILITY_2_4
+

 wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parent,
                                     const wxString& text,
                                     int image, int selImage,
                                     long insertAfter)
 {
 wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parent,
                                     const wxString& text,
                                     int image, int selImage,
                                     long insertAfter)
 {

-    return DoInsertItem(parent, (WXHTREEITEM)insertAfter, text,
+    return DoInsertItem(parent, wxTreeItemId((void *)insertAfter), text,

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

+#endif // WXWIN_COMPATIBILITY_2_4
+

 wxTreeItemId wxTreeCtrl::AddRoot(const wxString& text,
                                  int image, int selectedImage,
                                  wxTreeItemData *data)
 {
 wxTreeItemId wxTreeCtrl::AddRoot(const wxString& text,
                                  int image, int selectedImage,
                                  wxTreeItemData *data)
 {

-    return DoInsertItem(wxTreeItemId((long) (WXHTREEITEM) 0), (long)(WXHTREEITEM) 0,
+
+    if ( m_windowStyle & wxTR_HIDE_ROOT )
+    {
+        // create a virtual root item, the parent for all the others
+        m_pVirtualRoot = new wxVirtualNode(data);
+
+        return TVI_ROOT;
+    }
+
+    return DoInsertItem(wxTreeItemId(), wxTreeItemId(),

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


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

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

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


@@ -1397,7 +1707,7 @@ wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parent,
                                     wxTreeItemData *data)
 {
     // find the item from index
                                     wxTreeItemData *data)
 {
     // find the item from index

-    long cookie;
+    wxTreeItemIdValue cookie;

     wxTreeItemId idPrev, idCur = GetFirstChild(parent, cookie);
     while ( index != 0 && idCur.IsOk() )
     {
     wxTreeItemId idPrev, idCur = GetFirstChild(parent, cookie);
     while ( index != 0 && idCur.IsOk() )
     {


@@ -1419,7 +1729,7 @@ wxTreeItemId wxTreeCtrl::AppendItem(const wxTreeItemId& parent,
                                     int image, int selectedImage,
                                     wxTreeItemData *data)
 {
                                     int image, int selectedImage,
                                     wxTreeItemData *data)
 {

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

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


@@ -1434,13 +1744,13 @@ void wxTreeCtrl::Delete(const wxTreeItemId& item)
 // delete all children (but don't delete the item itself)
 void wxTreeCtrl::DeleteChildren(const wxTreeItemId& item)
 {
 // delete all children (but don't delete the item itself)
 void wxTreeCtrl::DeleteChildren(const wxTreeItemId& item)
 {

-    long cookie;
+    wxTreeItemIdValue cookie;

 
 

-    wxArrayLong children;
+    wxArrayTreeItemIds children;

     wxTreeItemId child = GetFirstChild(item, cookie);
     while ( child.IsOk() )
     {
     wxTreeItemId child = GetFirstChild(item, cookie);
     while ( child.IsOk() )
     {

-        children.Add((long)(WXHTREEITEM)child);
+        children.Add(child);

 
         child = GetNextChild(item, cookie);
     }
 
         child = GetNextChild(item, cookie);
     }


@@ -1448,7 +1758,7 @@ void wxTreeCtrl::DeleteChildren(const wxTreeItemId& item)
     size_t nCount = children.Count();
     for ( size_t n = 0; n < nCount; n++ )
     {
     size_t nCount = children.Count();
     for ( size_t n = 0; n < nCount; n++ )
     {

-        if ( !TreeView_DeleteItem(GetHwnd(), (HTREEITEM)children[n]) )
+        if ( !TreeView_DeleteItem(GetHwnd(), HITEM_PTR(children[n])) )

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


@@ -1457,6 +1767,15 @@ void wxTreeCtrl::DeleteChildren(const wxTreeItemId& item)
 
 void wxTreeCtrl::DeleteAllItems()
 {
 
 void wxTreeCtrl::DeleteAllItems()
 {

+    // delete the "virtual" root item.
+    if ( GET_VIRTUAL_ROOT() )
+    {
+        delete GET_VIRTUAL_ROOT();
+        m_pVirtualRoot = NULL;
+    }
+
+    // and all the real items
+

     if ( !TreeView_DeleteAllItems(GetHwnd()) )
     {
         wxLogLastError(wxT("TreeView_DeleteAllItems"));
     if ( !TreeView_DeleteAllItems(GetHwnd()) )
     {
         wxLogLastError(wxT("TreeView_DeleteAllItems"));


@@ -1471,6 +1790,10 @@ void wxTreeCtrl::DoExpand(const wxTreeItemId& item, int flag)
                   flag == TVE_TOGGLE,
                   wxT("Unknown flag in wxTreeCtrl::DoExpand") );
 
                   flag == TVE_TOGGLE,
                   wxT("Unknown flag in wxTreeCtrl::DoExpand") );
 

+    // A hidden root can be neither expanded nor collapsed.
+    wxCHECK_RET( !(m_windowStyle & wxTR_HIDE_ROOT) || (HITEM(item) != TVI_ROOT),
+                 wxT("Can't expand/collapse hidden root node!") )
+

     // TreeView_Expand doesn't send TVN_ITEMEXPAND(ING) messages, so we must
     // emulate them. This behaviour has changed slightly with comctl32.dll
     // v 4.70 - now it does send them but only the first time. To maintain
     // TreeView_Expand doesn't send TVN_ITEMEXPAND(ING) messages, so we must
     // emulate them. This behaviour has changed slightly with comctl32.dll
     // v 4.70 - now it does send them but only the first time. To maintain


@@ -1487,17 +1810,15 @@ void wxTreeCtrl::DoExpand(const wxTreeItemId& item, int flag)
     {
         wxTreeEvent event(wxEVT_NULL, m_windowId);
         event.m_item = item;
     {
         wxTreeEvent event(wxEVT_NULL, m_windowId);
         event.m_item = item;

-
-        bool isExpanded = IsExpanded(item);
-

         event.SetEventObject(this);
 
         event.SetEventObject(this);
 

-        // FIXME return value of {EXPAND|COLLAPS}ING event handler is discarded
-        event.SetEventType(g_events[isExpanded][TRUE]);
-        GetEventHandler()->ProcessEvent(event);
+        // note that the {EXPAND|COLLAPS}ING event is sent by TreeView_Expand()
+        // itself
+        event.SetEventType(gs_expandEvents[IsExpanded(item) ? IDX_EXPAND
+                                                            : IDX_COLLAPSE]
+                                          [IDX_DONE]);

 
 

-        event.SetEventType(g_events[isExpanded][FALSE]);
-        GetEventHandler()->ProcessEvent(event);
+        (void)GetEventHandler()->ProcessEvent(event);

     }
     //else: change didn't took place, so do nothing at all
 }
     }
     //else: change didn't took place, so do nothing at all
 }


@@ -1522,10 +1843,12 @@ void wxTreeCtrl::Toggle(const wxTreeItemId& item)
     DoExpand(item, TVE_TOGGLE);
 }
 
     DoExpand(item, TVE_TOGGLE);
 }
 

+#if WXWIN_COMPATIBILITY_2_4

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

+#endif

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


@@ -1533,7 +1856,7 @@ void wxTreeCtrl::Unselect()
                   wxT("doesn't make sense, may be you want UnselectAll()?") );
 
     // just remove the selection
                   wxT("doesn't make sense, may be you want UnselectAll()?") );
 
     // just remove the selection

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

 }
 
 void wxTreeCtrl::UnselectAll()
 }
 
 void wxTreeCtrl::UnselectAll()


@@ -1545,9 +1868,9 @@ void wxTreeCtrl::UnselectAll()
         for ( size_t n = 0; n < count; n++ )
         {
 #if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
         for ( size_t n = 0; n < count; n++ )
         {
 #if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE

-            SetItemCheck(selections[n], FALSE);
+            SetItemCheck(HITEM_PTR(selections[n]), false);

 #else // !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
 #else // !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE

-            ::UnselectItem(GetHwnd(), HITEM(selections[n]));
+            ::UnselectItem(GetHwnd(), HITEM_PTR(selections[n]));

 #endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE/!wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
         }
     }
 #endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE/!wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
         }
     }


@@ -1558,19 +1881,22 @@ void wxTreeCtrl::UnselectAll()
     }
 }
 
     }
 }
 

-void wxTreeCtrl::SelectItem(const wxTreeItemId& item)
+void wxTreeCtrl::SelectItem(const wxTreeItemId& item, bool select)

 {
     if ( m_windowStyle & wxTR_MULTIPLE )
     {
 #if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
         // selecting the item means checking it
 {
     if ( m_windowStyle & wxTR_MULTIPLE )
     {
 #if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
         // selecting the item means checking it

-        SetItemCheck(item);
+        SetItemCheck(item, select);

 #else // !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
 #else // !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE

-        ::SelectItem(GetHwnd(), HITEM(item));
+        ::SelectItem(GetHwnd(), HITEM(item), select);

 #endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE/!wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
     }
     else
     {
 #endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE/!wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
     }
     else
     {

+        wxASSERT_MSG( select,
+                      _T("SelectItem(false) works only for multiselect") );
+

         // inspite of the docs (MSDN Jan 99 edition), we don't seem to receive
         // the notification from the control (i.e. TVN_SELCHANG{ED|ING}), so
         // send them ourselves
         // inspite of the docs (MSDN Jan 99 edition), we don't seem to receive
         // the notification from the control (i.e. TVN_SELCHANG{ED|ING}), so
         // send them ourselves


@@ -1586,7 +1912,7 @@ void wxTreeCtrl::SelectItem(const wxTreeItemId& item)
             {
                 wxLogLastError(wxT("TreeView_SelectItem"));
             }
             {
                 wxLogLastError(wxT("TreeView_SelectItem"));
             }

-            else
+            else // ok

             {
                 event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
                 (void)GetEventHandler()->ProcessEvent(event);
             {
                 event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
                 (void)GetEventHandler()->ProcessEvent(event);


@@ -1596,6 +1922,16 @@ void wxTreeCtrl::SelectItem(const wxTreeItemId& item)
     }
 }
 
     }
 }
 

+void wxTreeCtrl::UnselectItem(const wxTreeItemId& item)
+{
+    SelectItem(item, false);
+}
+
+void wxTreeCtrl::ToggleItemSelection(const wxTreeItemId& item)
+{
+    SelectItem(item, !IsSelected(item));
+}
+

 void wxTreeCtrl::EnsureVisible(const wxTreeItemId& item)
 {
     // no error return
 void wxTreeCtrl::EnsureVisible(const wxTreeItemId& item)
 {
     // no error return


@@ -1610,26 +1946,8 @@ void wxTreeCtrl::ScrollTo(const wxTreeItemId& item)
     }
 }
 
     }
 }
 

-wxTextCtrl* wxTreeCtrl::GetEditControl() const
+wxTextCtrl *wxTreeCtrl::GetEditControl() const

 {
 {

-    // normally, we could try to do something like this to return something
-    // even when the editing was started by the user and not by calling
-    // EditLabel() - but as nobody has asked for this so far and there might be
-    // problems in the code below, I leave it disabled for now (VZ)
-#if 0
-    if ( !m_textCtrl )
-    {
-        HWND hwndText = TreeView_GetEditControl(GetHwnd());
-        if ( hwndText )
-        {
-            m_textCtrl = new wxTextCtrl(this, -1);
-            m_textCtrl->Hide();
-            m_textCtrl->SetHWND((WXHWND)hwndText);
-        }
-        //else: not editing label right now
-    }
-#endif // 0
-

     return m_textCtrl;
 }
 
     return m_textCtrl;
 }
 


@@ -1659,20 +1977,19 @@ wxTextCtrl* wxTreeCtrl::EditLabel(const wxTreeItemId& item,
 
     DeleteTextCtrl();
 
 
     DeleteTextCtrl();
 

+    m_textCtrl = (wxTextCtrl *)textControlClass->CreateObject();

     HWND hWnd = (HWND) TreeView_EditLabel(GetHwnd(), HITEM(item));
 
     // this is not an error - the TVN_BEGINLABELEDIT handler might have
     HWND hWnd = (HWND) TreeView_EditLabel(GetHwnd(), HITEM(item));
 
     // this is not an error - the TVN_BEGINLABELEDIT handler might have

-    // returned FALSE
+    // returned false

     if ( !hWnd )
     {
     if ( !hWnd )
     {

+        delete m_textCtrl;
+        m_textCtrl = NULL;

         return NULL;
     }
 
         return NULL;
     }
 

-    m_textCtrl = (wxTextCtrl *)textControlClass->CreateObject();
-    m_textCtrl->SetParent(this);
-    m_textCtrl->SetHWND((WXHWND)hWnd);
-    m_textCtrl->SubclassWin((WXHWND)hWnd);
-
+    // textctrl is subclassed in MSWOnNotify

     return m_textCtrl;
 }
 
     return m_textCtrl;
 }
 


@@ -1712,7 +2029,7 @@ wxTreeItemId wxTreeCtrl::HitTest(const wxPoint& point, int& flags)
 
     #undef TRANSLATE_FLAG
 
 
     #undef TRANSLATE_FLAG
 

-    return wxTreeItemId((WXHTREEITEM) hitTestInfo.hItem);
+    return wxTreeItemId(hitTestInfo.hItem);

 }
 
 bool wxTreeCtrl::GetBoundingRect(const wxTreeItemId& item,
 }
 
 bool wxTreeCtrl::GetBoundingRect(const wxTreeItemId& item,


@@ -1720,17 +2037,24 @@ bool wxTreeCtrl::GetBoundingRect(const wxTreeItemId& item,
                                  bool textOnly) const
 {
     RECT rc;
                                  bool textOnly) const
 {
     RECT rc;

+
+    // Virtual root items have no bounding rectangle
+    if ( IS_VIRTUAL_ROOT(item) )
+    {
+        return false;
+    }
+

     if ( TreeView_GetItemRect(GetHwnd(), HITEM(item),
                               &rc, textOnly) )
     {
         rect = wxRect(wxPoint(rc.left, rc.top), wxPoint(rc.right, rc.bottom));
 
     if ( TreeView_GetItemRect(GetHwnd(), HITEM(item),
                               &rc, textOnly) )
     {
         rect = wxRect(wxPoint(rc.left, rc.top), wxPoint(rc.right, rc.bottom));
 

-        return TRUE;
+        return true;

     }
     else
     {
         // couldn't retrieve rect: for example, item isn't visible
     }
     else
     {
         // couldn't retrieve rect: for example, item isn't visible

-        return FALSE;
+        return false;

     }
 }
 
     }
 }
 


@@ -1738,14 +2062,37 @@ bool wxTreeCtrl::GetBoundingRect(const wxTreeItemId& item,
 // sorting stuff
 // ----------------------------------------------------------------------------
 
 // sorting stuff
 // ----------------------------------------------------------------------------
 

-static int CALLBACK TreeView_CompareCallback(wxTreeItemData *pItem1,
-                                             wxTreeItemData *pItem2,
-                                             wxTreeCtrl *tree)
+// this is just a tiny namespace which is friend to wxTreeCtrl and so can use
+// functions such as IsDataIndirect()
+class wxTreeSortHelper
+{
+public:
+    static int CALLBACK Compare(LPARAM data1, LPARAM data2, LPARAM tree);
+
+private:
+    static wxTreeItemId GetIdFromData(wxTreeCtrl *tree, LPARAM item)
+    {
+        wxTreeItemData *data = (wxTreeItemData *)item;
+        if ( tree->IsDataIndirect(data) )
+        {
+            data = ((wxTreeItemIndirectData *)data)->GetData();
+        }
+
+        return data->GetId();
+    }
+};
+
+int CALLBACK wxTreeSortHelper::Compare(LPARAM pItem1,
+                                       LPARAM pItem2,
+                                       LPARAM htree)

 {
     wxCHECK_MSG( pItem1 && pItem2, 0,
                  wxT("sorting tree without data doesn't make sense") );
 
 {
     wxCHECK_MSG( pItem1 && pItem2, 0,
                  wxT("sorting tree without data doesn't make sense") );
 

-    return tree->OnCompareItems(pItem1->GetId(), pItem2->GetId());
+    wxTreeCtrl *tree = (wxTreeCtrl *)htree;
+
+    return tree->OnCompareItems(GetIdFromData(tree, pItem1),
+                                GetIdFromData(tree, pItem2));

 }
 
 int wxTreeCtrl::OnCompareItems(const wxTreeItemId& item1,
 }
 
 int wxTreeCtrl::OnCompareItems(const wxTreeItemId& item1,


@@ -1767,7 +2114,7 @@ void wxTreeCtrl::SortChildren(const wxTreeItemId& item)
     {
         TV_SORTCB tvSort;
         tvSort.hParent = HITEM(item);
     {
         TV_SORTCB tvSort;
         tvSort.hParent = HITEM(item);

-        tvSort.lpfnCompare = (PFNTVCOMPARE)TreeView_CompareCallback;
+        tvSort.lpfnCompare = wxTreeSortHelper::Compare;

         tvSort.lParam = (LPARAM)this;
         TreeView_SortChildrenCB(GetHwnd(), &tvSort, 0 /* reserved */);
     }
         tvSort.lParam = (LPARAM)this;
         TreeView_SortChildrenCB(GetHwnd(), &tvSort, 0 /* reserved */);
     }


@@ -1794,33 +2141,48 @@ bool wxTreeCtrl::MSWCommand(WXUINT cmd, WXWORD id)
     else
     {
         // nothing done
     else
     {
         // nothing done

-        return FALSE;
+        return false;

     }
 
     // command processed
     }
 
     // command processed

-    return TRUE;
+    return true;

 }
 
 // we hook into WndProc to process WM_MOUSEMOVE/WM_BUTTONUP messages - as we
 // only do it during dragging, minimize wxWin overhead (this is important for
 // WM_MOUSEMOVE as they're a lot of them) by catching Windows messages directly
 // instead of passing by wxWin events
 }
 
 // we hook into WndProc to process WM_MOUSEMOVE/WM_BUTTONUP messages - as we
 // only do it during dragging, minimize wxWin overhead (this is important for
 // WM_MOUSEMOVE as they're a lot of them) by catching Windows messages directly
 // instead of passing by wxWin events

-long wxTreeCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
+WXLRESULT wxTreeCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)

 {
 {

-    bool processed = FALSE;
-    long rc = 0;
+    bool processed = false;
+    WXLRESULT rc = 0;

     bool isMultiple = (GetWindowStyle() & wxTR_MULTIPLE) != 0;
 
     if ( (nMsg >= WM_MOUSEFIRST) && (nMsg <= WM_MOUSELAST) )
     {
     bool isMultiple = (GetWindowStyle() & wxTR_MULTIPLE) != 0;
 
     if ( (nMsg >= WM_MOUSEFIRST) && (nMsg <= WM_MOUSELAST) )
     {

-        // we only process mouse messages here and these parameters have the same
-        // meaning for all of them
+        // we only process mouse messages here and these parameters have the
+        // same meaning for all of them

         int x = GET_X_LPARAM(lParam),
             y = GET_Y_LPARAM(lParam);
         HTREEITEM htItem = GetItemFromPoint(GetHwnd(), x, y);
 
         switch ( nMsg )
         {
         int x = GET_X_LPARAM(lParam),
             y = GET_Y_LPARAM(lParam);
         HTREEITEM htItem = GetItemFromPoint(GetHwnd(), x, y);
 
         switch ( nMsg )
         {

+            case WM_RBUTTONDOWN:
+                // if the item we are about to right click on is not already
+                // selected or if we click outside of any item, remove the
+                // entire previous selection
+                if ( !htItem || !::IsItemSelected(GetHwnd(), htItem) )
+                {
+                    UnselectAll();
+                }
+
+                // select item and set the focus to the
+                // newly selected item
+                ::SelectItem(GetHwnd(), htItem);
+                ::SetFocus(GetHwnd(), htItem);
+                break;
+

 #if !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
             case WM_LBUTTONDOWN:
                 if ( htItem && isMultiple )
 #if !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
             case WM_LBUTTONDOWN:
                 if ( htItem && isMultiple )


@@ -1830,14 +2192,14 @@ long wxTreeCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
                         SetFocus();
 
                         // toggle selected state
                         SetFocus();
 
                         // toggle selected state

-                        ToggleItemSelection(GetHwnd(), htItem);
+                        ::ToggleItemSelection(GetHwnd(), htItem);

 
                         ::SetFocus(GetHwnd(), htItem);
 
                         // reset on any click without Shift
 
                         ::SetFocus(GetHwnd(), htItem);
 
                         // reset on any click without Shift

-                        m_htSelStart = 0;
+                        m_htSelStart.Unset();

 
 

-                        processed = TRUE;
+                        processed = true;

                     }
                     else if ( wParam & MK_SHIFT )
                     {
                     }
                     else if ( wParam & MK_SHIFT )
                     {


@@ -1847,8 +2209,7 @@ long wxTreeCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
                         if ( !m_htSelStart )
                         {
                             // take the focused item
                         if ( !m_htSelStart )
                         {
                             // take the focused item

-                            m_htSelStart = (WXHTREEITEM)
-                                TreeView_GetSelection(GetHwnd());
+                            m_htSelStart = TreeView_GetSelection(GetHwnd());

                         }
 
                         SelectRange(GetHwnd(), HITEM(m_htSelStart), htItem,
                         }
 
                         SelectRange(GetHwnd(), HITEM(m_htSelStart), htItem,


@@ -1856,20 +2217,44 @@ long wxTreeCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
 
                         ::SetFocus(GetHwnd(), htItem);
 
 
                         ::SetFocus(GetHwnd(), htItem);
 

-                        processed = TRUE;
+                        processed = true;

                     }
                     else // normal click
                     {
                     }
                     else // normal click
                     {

-                        // clear the selection and then let the default handler
-                        // do the job
-                        UnselectAll();
+                        // avoid doing anything if we click on the only
+                        // currently selected item
+
+                        wxArrayTreeItemIds selections;
+                        size_t count = GetSelections(selections);
+                        if ( count == 0 ||
+                             count > 1 ||
+                             HITEM_PTR(selections[0]) != htItem )
+                        {
+                            // clear the previously selected items, if the
+                            // user clicked outside of the present selection.
+                            // otherwise, perform the deselection on mouse-up.
+                            // this allows multiple drag and drop to work.

 
 

-                        // prevent the click from starting in-place editing
-                        // when there was no selection in the control
-                        TreeView_SelectItem(GetHwnd(), 0);
+                            if (IsItemSelected(GetHwnd(), htItem))
+                            {
+                                ::SetFocus(GetHwnd(), htItem);
+                            }
+                             else
+                            {
+                                UnselectAll();
+
+                                // prevent the click from starting in-place editing
+                                // which should only happen if we click on the
+                                // already selected item (and nothing else is
+                                // selected)
+
+                                TreeView_SelectItem(GetHwnd(), 0);
+                                ::SelectItem(GetHwnd(), htItem);
+                            }
+                        }

 
                         // reset on any click without Shift
 
                         // reset on any click without Shift

-                        m_htSelStart = 0;
+                        m_htSelStart.Unset();

                     }
                 }
                 break;
                     }
                 }
                 break;


@@ -1891,6 +2276,24 @@ long wxTreeCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
                 break;
 
             case WM_LBUTTONUP:
                 break;
 
             case WM_LBUTTONUP:

+
+                // facilitates multiple drag-and-drop
+                if (htItem && isMultiple)
+                {
+                    wxArrayTreeItemIds selections;
+                    size_t count = GetSelections(selections);
+
+                    if (count > 1 &&
+                        !(wParam & MK_CONTROL) &&
+                        !(wParam & MK_SHIFT))
+                    {
+                        UnselectAll();
+                        TreeView_SelectItem(GetHwnd(), htItem);
+                    }
+                }
+
+                // fall through
+

             case WM_RBUTTONUP:
                 if ( m_dragImage )
                 {
             case WM_RBUTTONUP:
                 if ( m_dragImage )
                 {


@@ -1901,7 +2304,7 @@ long wxTreeCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
                     // generate the drag end event
                     wxTreeEvent event(wxEVT_COMMAND_TREE_END_DRAG, m_windowId);
 
                     // generate the drag end event
                     wxTreeEvent event(wxEVT_COMMAND_TREE_END_DRAG, m_windowId);
 

-                    event.m_item = (WXHTREEITEM)htItem;
+                    event.m_item = htItem;

                     event.m_pointDrag = wxPoint(x, y);
                     event.SetEventObject(this);
 
                     event.m_pointDrag = wxPoint(x, y);
                     event.SetEventObject(this);
 


@@ -1925,12 +2328,12 @@ long wxTreeCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
         RECT rect;
         for ( size_t n = 0; n < count; n++ )
         {
         RECT rect;
         for ( size_t n = 0; n < count; n++ )
         {

-            // TreeView_GetItemRect() will return FALSE if item is not visible,
+            // TreeView_GetItemRect() will return false if item is not visible,

             // which may happen perfectly well
             // which may happen perfectly well

-            if ( TreeView_GetItemRect(GetHwnd(), HITEM(selections[n]),
-                                      &rect, TRUE) )
+            if ( TreeView_GetItemRect(GetHwnd(), HITEM_PTR(selections[n]),
+                                      &rect, true) )

             {
             {

-                ::InvalidateRect(GetHwnd(), &rect, FALSE);
+                ::InvalidateRect(GetHwnd(), &rect, false);

             }
         }
     }
             }
         }
     }


@@ -1945,14 +2348,14 @@ long wxTreeCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
         HTREEITEM htSel = (HTREEITEM)TreeView_GetSelection(GetHwnd());
         if ( !m_htSelStart )
         {
         HTREEITEM htSel = (HTREEITEM)TreeView_GetSelection(GetHwnd());
         if ( !m_htSelStart )
         {

-            m_htSelStart = (WXHTREEITEM)htSel;
+            m_htSelStart = htSel;

         }
 
         if ( wParam == VK_SPACE )
         {
             if ( bCtrl )
             {
         }
 
         if ( wParam == VK_SPACE )
         {
             if ( bCtrl )
             {

-                ToggleItemSelection(GetHwnd(), htSel);
+                ::ToggleItemSelection(GetHwnd(), htSel);

             }
             else
             {
             }
             else
             {


@@ -1961,7 +2364,7 @@ long wxTreeCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
                 ::SelectItem(GetHwnd(), htSel);
             }
 
                 ::SelectItem(GetHwnd(), htSel);
             }
 

-            processed = TRUE;
+            processed = true;

         }
         else if ( wParam == VK_UP || wParam == VK_DOWN )
         {
         }
         else if ( wParam == VK_UP || wParam == VK_DOWN )
         {


@@ -1995,11 +2398,24 @@ long wxTreeCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
                     ::SetFocus(GetHwnd(), htNext);
                 }
 
                     ::SetFocus(GetHwnd(), htNext);
                 }
 

-                processed = TRUE;
+                processed = true;

             }
         }
     }
 #endif // !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
             }
         }
     }
 #endif // !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE

+    else if ( nMsg == WM_CHAR )
+    {
+        // don't let the control process Space and Return keys because it
+        // doesn't do anything useful with them anyhow but always beeps
+        // annoyingly when it receives them and there is no way to turn it off
+        // simply if you just process TREEITEM_ACTIVATED event to which Space
+        // and Enter presses are mapped in your code
+        if ( wParam == VK_SPACE || wParam == VK_RETURN )
+        {
+            processed = true;
+        }
+    }
+

     if ( !processed )
         rc = wxControl::MSWWindowProc(nMsg, wParam, lParam);
 
     if ( !processed )
         rc = wxControl::MSWWindowProc(nMsg, wParam, lParam);
 


@@ -2027,7 +2443,7 @@ bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
 
                 NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
 
 
                 NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
 

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

                 event.m_pointDrag = wxPoint(tv->ptDrag.x, tv->ptDrag.y);
 
                 // don't allow dragging by default: the user code must
                 event.m_pointDrag = wxPoint(tv->ptDrag.x, tv->ptDrag.y);
 
                 // don't allow dragging by default: the user code must


@@ -2042,8 +2458,9 @@ bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
                 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 = (WXHTREEITEM) info->item.hItem;
+                event.m_item = info->item.hItem;

                 event.m_label = info->item.pszText;
                 event.m_label = info->item.pszText;

+                event.m_editCancelled = false;

             }
             break;
 
             }
             break;
 


@@ -2052,12 +2469,16 @@ bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
                 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 = (WXHTREEITEM)tv->itemOld.hItem;
+                event.m_item = tv->itemOld.hItem;

 
                 if ( m_hasAnyAttr )
                 {
 
                 if ( m_hasAnyAttr )
                 {

-                    delete (wxTreeItemAttr *)m_attrs.
-                                Delete((long)tv->itemOld.hItem);
+                    wxMapTreeAttr::iterator it = m_attrs.find(tv->itemOld.hItem);
+                    if ( it != m_attrs.end() )
+                    {
+                        delete it->second;
+                        m_attrs.erase(it);
+                    }

                 }
             }
             break;
                 }
             }
             break;


@@ -2067,13 +2488,36 @@ bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
                 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 = (WXHTREEITEM)info->item.hItem;
+                event.m_item = info->item.hItem;

                 event.m_label = info->item.pszText;
                 event.m_label = info->item.pszText;

-                if (info->item.pszText == NULL)
-                    return FALSE;
+                event.m_editCancelled = info->item.pszText == NULL;
+                break;
+            }
+
+#ifndef __WXWINCE__
+        // These *must* not be removed or TVN_GETINFOTIP will
+        // not be processed each time the mouse is moved
+        // and the tooltip will only ever update once.
+        case TTN_NEEDTEXTA:
+        case TTN_NEEDTEXTW:
+            {
+                *result = 0;
+

                 break;
             }
 
                 break;
             }
 

+        case TVN_GETINFOTIP:
+            {
+                eventType = wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP;
+                NMTVGETINFOTIP *info = (NMTVGETINFOTIP*)lParam;
+
+                // Which item are we trying to get a tooltip for?
+                event.m_item = info->hItem;
+
+                break;
+            }
+#endif
+

         case TVN_GETDISPINFO:
             eventType = wxEVT_COMMAND_TREE_GET_INFO;
             // fall through
         case TVN_GETDISPINFO:
             eventType = wxEVT_COMMAND_TREE_GET_INFO;
             // fall through


@@ -2086,7 +2530,7 @@ bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
 
                 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
 
 
                 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
 

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

                 break;
             }
 
                 break;
             }
 


@@ -2095,25 +2539,28 @@ bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
             {
                 NM_TREEVIEW* tv = (NM_TREEVIEW*)lParam;
 
             {
                 NM_TREEVIEW* tv = (NM_TREEVIEW*)lParam;
 

-                bool expand = FALSE;
+                int what;

                 switch ( tv->action )
                 {
                 switch ( tv->action )
                 {

+                    default:
+                        wxLogDebug(wxT("unexpected code %d in TVN_ITEMEXPAND message"), tv->action);
+                        // fall through
+

                     case TVE_EXPAND:
                     case TVE_EXPAND:

-                        expand = TRUE;
+                        what = IDX_EXPAND;

                         break;
 
                     case TVE_COLLAPSE:
                         break;
 
                     case TVE_COLLAPSE:

-                        expand = FALSE;
+                        what = IDX_COLLAPSE;

                         break;
                         break;

-
-                    default:
-                        wxLogDebug(wxT("unexpected code %d in TVN_ITEMEXPAND message"), tv->action);

                 }
 
                 }
 

-                bool ing = ((int)hdr->code == TVN_ITEMEXPANDING);
-                eventType = g_events[expand][ing];
+                int how = hdr->code == TVN_ITEMEXPANDING ? IDX_DOING
+                                                         : IDX_DONE;

 
 

-                event.m_item = (WXHTREEITEM) tv->itemNew.hItem;
+                eventType = gs_expandEvents[what][how];
+
+                event.m_item = tv->itemNew.hItem;

             }
             break;
 
             }
             break;
 


@@ -2122,13 +2569,26 @@ bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
                 eventType = wxEVT_COMMAND_TREE_KEY_DOWN;
                 TV_KEYDOWN *info = (TV_KEYDOWN *)lParam;
 
                 eventType = wxEVT_COMMAND_TREE_KEY_DOWN;
                 TV_KEYDOWN *info = (TV_KEYDOWN *)lParam;
 

-                // we pass 0 as last CreateKeyEvent() parameter because we
-                // don't have access to the real key press flags here - but as
-                // it is only used to determin wxKeyEvent::m_altDown flag it's
-                // not too bad
+                // fabricate the lParam and wParam parameters sufficiently
+                // similar to the ones from a "real" WM_KEYDOWN so that
+                // CreateKeyEvent() works correctly
+                WXLPARAM lParam =
+                     (::GetKeyState(VK_MENU) < 0 ? KF_ALTDOWN : 0) << 16;
+
+                WXWPARAM wParam = info->wVKey;
+
+                int keyCode = wxCharCodeMSWToWX(info->wVKey);
+                if ( !keyCode )
+                {
+                    // wxCharCodeMSWToWX() returns 0 to indicate that this is a
+                    // simple ASCII key
+                    keyCode = wParam;
+                }
+

                 event.m_evtKey = CreateKeyEvent(wxEVT_KEY_DOWN,
                 event.m_evtKey = CreateKeyEvent(wxEVT_KEY_DOWN,

-                                                wxCharCodeMSWToWX(info->wVKey),
-                                                0);
+                                                keyCode,
+                                                lParam,
+                                                wParam);

 
                 // a separate event for Space/Return
                 if ( !wxIsCtrlDown() && !wxIsShiftDown() &&
 
                 // a separate event for Space/Return
                 if ( !wxIsCtrlDown() && !wxIsShiftDown() &&


@@ -2148,24 +2608,40 @@ bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
             }
             break;
 
             }
             break;
 

-        case TVN_SELCHANGED:
+        // NB: MSLU is broken and sends TVN_SELCHANGEDA instead of
+        //     TVN_SELCHANGEDW in Unicode mode under Win98. Therefore
+        //     we have to handle both messages:
+        case TVN_SELCHANGEDA:
+        case TVN_SELCHANGEDW:

             eventType = wxEVT_COMMAND_TREE_SEL_CHANGED;
             // fall through
 
             eventType = wxEVT_COMMAND_TREE_SEL_CHANGED;
             // fall through
 

-        case TVN_SELCHANGING:
+        case TVN_SELCHANGINGA:
+        case TVN_SELCHANGINGW:

             {
                 if ( eventType == wxEVT_NULL )
                     eventType = wxEVT_COMMAND_TREE_SEL_CHANGING;
                 //else: already set above
 
             {
                 if ( eventType == wxEVT_NULL )
                     eventType = wxEVT_COMMAND_TREE_SEL_CHANGING;
                 //else: already set above
 

-                NM_TREEVIEW* tv = (NM_TREEVIEW *)lParam;
-
-                event.m_item = (WXHTREEITEM) tv->itemNew.hItem;
-                event.m_itemOld = (WXHTREEITEM) tv->itemOld.hItem;
+                if (hdr->code == TVN_SELCHANGINGW ||
+                    hdr->code == TVN_SELCHANGEDW)
+                {
+                    NM_TREEVIEWW* tv = (NM_TREEVIEWW *)lParam;
+                    event.m_item = tv->itemNew.hItem;
+                    event.m_itemOld = tv->itemOld.hItem;
+                }
+                else
+                {
+                    NM_TREEVIEWA* tv = (NM_TREEVIEWA *)lParam;
+                    event.m_item = tv->itemNew.hItem;
+                    event.m_itemOld = tv->itemOld.hItem;
+                }

             }
             break;
 
             }
             break;
 

-#if defined(_WIN32_IE) && _WIN32_IE >= 0x300 && !wxUSE_COMCTL32_SAFELY && !( defined(__GNUWIN32__) && !wxCHECK_W32API_VERSION( 1, 0 ) )
+            // instead of explicitly checking for _WIN32_IE, check if the
+            // required symbols are available in the headers
+#if defined(CDDS_PREPAINT) && !wxUSE_COMCTL32_SAFELY

         case NM_CUSTOMDRAW:
             {
                 LPNMTVCUSTOMDRAW lptvcd = (LPNMTVCUSTOMDRAW)lParam;
         case NM_CUSTOMDRAW:
             {
                 LPNMTVCUSTOMDRAW lptvcd = (LPNMTVCUSTOMDRAW)lParam;


@@ -2181,73 +2657,54 @@ bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
 
                     case CDDS_ITEMPREPAINT:
                         {
 
                     case CDDS_ITEMPREPAINT:
                         {

-                            wxTreeItemAttr *attr =
-                                (wxTreeItemAttr *)m_attrs.Get(nmcd.dwItemSpec);
+                            wxMapTreeAttr::iterator
+                                it = m_attrs.find((void *)nmcd.dwItemSpec);

 
 

-                            if ( !attr )
+                            if ( it == m_attrs.end() )

                             {
                                 // nothing to do for this item
                                 *result = CDRF_DODEFAULT;
                                 break;
                             }
 
                             {
                                 // nothing to do for this item
                                 *result = CDRF_DODEFAULT;
                                 break;
                             }
 

-                            HFONT hFont;
-                            wxColour colText, colBack;
-                            if ( attr->HasFont() )
-                            {
-                                wxFont font = attr->GetFont();
-                                hFont = (HFONT)font.GetResourceHandle();
-                            }
-                            else
-                            {
-                                hFont = 0;
-                            }
+                            wxTreeItemAttr * const attr = it->second;

 
 

-                            if ( attr->HasTextColour() )
-                            {
-                                colText = attr->GetTextColour();
-                            }
-                            else
-                            {
-                                colText = GetForegroundColour();
-                            }
-
-                            // selection colours should override ours
-                            if ( nmcd.uItemState & CDIS_SELECTED )
-                            {
-                                DWORD clrBk = ::GetSysColor(COLOR_HIGHLIGHT);
-                                lptvcd->clrTextBk = clrBk;
-
-                                // try to make the text visible
-                                lptvcd->clrText = wxColourToRGB(colText);
-                                lptvcd->clrText |= ~clrBk;
-                                lptvcd->clrText &= 0x00ffffff;
-                            }
-                            else
+                            // selection colours should override ours,
+                            // otherwise it is too confusing ot the user
+                            if ( !(nmcd.uItemState & CDIS_SELECTED) )

                             {
                             {

+                                wxColour colBack;

                                 if ( attr->HasBackgroundColour() )
                                 {
                                     colBack = attr->GetBackgroundColour();
                                 if ( attr->HasBackgroundColour() )
                                 {
                                     colBack = attr->GetBackgroundColour();

+                                    lptvcd->clrTextBk = wxColourToRGB(colBack);

                                 }
                                 }

-                                else
+                            }
+
+                            // but we still want to keep the special foreground
+                            // colour when we don't have focus (we can't keep
+                            // it when we do, it would usually be unreadable on
+                            // the almost inverted bg colour...)
+                            if ( !(nmcd.uItemState & CDIS_SELECTED) ||
+                                    FindFocus() != this )
+                            {
+                                wxColour colText;
+                                if ( attr->HasTextColour() )

                                 {
                                 {

-                                    colBack = GetBackgroundColour();
+                                    colText = attr->GetTextColour();
+                                    lptvcd->clrText = wxColourToRGB(colText);

                                 }
                                 }

-
-                                lptvcd->clrText = wxColourToRGB(colText);
-                                lptvcd->clrTextBk = wxColourToRGB(colBack);

                             }
 
                             }
 

-                            // note that if we wanted to set colours for
-                            // individual columns (subitems), we would have
-                            // returned CDRF_NOTIFYSUBITEMREDRAW from here
-                            if ( hFont )
+                            if ( attr->HasFont() )

                             {
                             {

+                                HFONT hFont = GetHfontOf(attr->GetFont());
+

                                 ::SelectObject(nmcd.hdc, hFont);
 
                                 *result = CDRF_NEWFONT;
                             }
                                 ::SelectObject(nmcd.hdc, hFont);
 
                                 *result = CDRF_NEWFONT;
                             }

-                            else
+                            else // no specific font

                             {
                                 *result = CDRF_DODEFAULT;
                             }
                             {
                                 *result = CDRF_DODEFAULT;
                             }


@@ -2260,8 +2717,25 @@ bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
             }
 
             // we always process it
             }
 
             // we always process it

-            return TRUE;
-#endif // _WIN32_IE >= 0x300
+            return true;
+#endif // have owner drawn support in headers
+
+        case NM_CLICK:
+            {
+                DWORD pos = GetMessagePos();
+                POINT point;
+                point.x = LOWORD(pos);
+                point.y = HIWORD(pos);
+                ::MapWindowPoints(HWND_DESKTOP, GetHwnd(), &point, 1);
+                int flags = 0;
+                wxTreeItemId item = HitTest(wxPoint(point.x, point.y), flags);
+                if (flags & wxTREE_HITTEST_ONITEMSTATEICON)
+                {
+                    event.m_item = item;
+                    eventType = wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK;
+                }
+                break;
+            }

 
         case NM_DBLCLK:
         case NM_RCLICK:
 
         case NM_DBLCLK:
         case NM_RCLICK:


@@ -2273,7 +2747,7 @@ bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
                 {
                     if ( tvhti.flags & TVHT_ONITEM )
                     {
                 {
                     if ( tvhti.flags & TVHT_ONITEM )
                     {

-                        event.m_item = (WXHTREEITEM) tvhti.hItem;
+                        event.m_item = tvhti.hItem;

                         eventType = (int)hdr->code == NM_DBLCLK
                                     ? wxEVT_COMMAND_TREE_ITEM_ACTIVATED
                                     : wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK;
                         eventType = (int)hdr->code == NM_DBLCLK
                                     ? wxEVT_COMMAND_TREE_ITEM_ACTIVATED
                                     : wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK;


@@ -2304,7 +2778,7 @@ bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
             // the return code of this event handler as the return value for
             // NM_DBLCLK - otherwise, double clicking the item to toggle its
             // expanded status would never work
             // the return code of this event handler as the return value for
             // NM_DBLCLK - otherwise, double clicking the item to toggle its
             // expanded status would never work

-            *result = FALSE;
+            *result = false;

             break;
 
         case TVN_BEGINDRAG:
             break;
 
         case TVN_BEGINDRAG:


@@ -2335,13 +2809,6 @@ bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
                     wxTreeItemIndirectData *data = (wxTreeItemIndirectData *)
                                                         tv->itemOld.lParam;
                     delete data; // can't be NULL here
                     wxTreeItemIndirectData *data = (wxTreeItemIndirectData *)
                                                         tv->itemOld.lParam;
                     delete data; // can't be NULL here

-
-                    m_itemsWithIndirectData.Remove(item);
-#if 0
-                    int iIndex = m_itemsWithIndirectData.Index(item);
-                    wxASSERT( iIndex != wxNOT_FOUND) ;
-                    m_itemsWithIndirectData.wxBaseArray::RemoveAt((size_t)iIndex);
-#endif

                 }
                 else
                 {
                 }
                 else
                 {


@@ -2349,38 +2816,92 @@ bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
                     delete data; // may be NULL, ok
                 }
 
                     delete data; // may be NULL, ok
                 }
 

-                processed = TRUE; // Make sure we don't get called twice
+                processed = true; // Make sure we don't get called twice

             }
             break;
 
         case TVN_BEGINLABELEDIT:
             }
             break;
 
         case TVN_BEGINLABELEDIT:

-            // return TRUE to cancel label editing
+            // return true to cancel label editing

             *result = !event.IsAllowed();
             *result = !event.IsAllowed();

+            // set ES_WANTRETURN ( like we do in BeginLabelEdit )
+            if(event.IsAllowed())
+            {
+                HWND hText = TreeView_GetEditControl(GetHwnd());
+                if(hText != NULL)
+                {
+                    // MBN: if m_textCtrl already has an HWND, it is a stale
+                    // pointer from a previous edit (because the user
+                    // didn't modify the label before dismissing the control,
+                    // and TVN_ENDLABELEDIT was not sent), so delete it
+                    if(m_textCtrl && m_textCtrl->GetHWND() != 0)
+                        DeleteTextCtrl();
+                    if(!m_textCtrl)
+                        m_textCtrl = new wxTextCtrl();
+                    m_textCtrl->SetParent(this);
+                    m_textCtrl->SetHWND((WXHWND)hText);
+                    m_textCtrl->SubclassWin((WXHWND)hText);
+
+                    // set wxTE_PROCESS_ENTER style for the text control to
+                    // force it to process the Enter presses itself, otherwise
+                    // they could be stolen from it by the dialog
+                    // navigation code
+                    m_textCtrl->SetWindowStyle(m_textCtrl->GetWindowStyle()
+                                               | wxTE_PROCESS_ENTER);
+                }
+            }

             break;
 
         case TVN_ENDLABELEDIT:
             break;
 
         case TVN_ENDLABELEDIT:

-            // return TRUE to set the label to the new string: note that we
+            // return true to set the label to the new string: note that we

             // also must pretend that we did process the message or it is going
             // also must pretend that we did process the message or it is going

-            // to be passed to DefWindowProc() which will happily return FALSE
+            // to be passed to DefWindowProc() which will happily return false

             // cancelling the label change
             *result = event.IsAllowed();
             // cancelling the label change
             *result = event.IsAllowed();

-            processed = TRUE;
+            processed = true;

 
             // ensure that we don't have the text ctrl which is going to be
             // deleted any more
             DeleteTextCtrl();
             break;
 
 
             // ensure that we don't have the text ctrl which is going to be
             // deleted any more
             DeleteTextCtrl();
             break;
 

+#ifndef __WXWINCE__
+         case TVN_GETINFOTIP:
+            {
+                // If the user permitted a tooltip change, change it
+                if (event.IsAllowed())
+                {
+                    SetToolTip(event.m_label);
+                }
+            }
+            break;
+#endif
+

         case TVN_SELCHANGING:
         case TVN_ITEMEXPANDING:
         case TVN_SELCHANGING:
         case TVN_ITEMEXPANDING:

-            // return TRUE to prevent the action from happening
+            // return true to prevent the action from happening

             *result = !event.IsAllowed();
             break;
 
             *result = !event.IsAllowed();
             break;
 

+        case TVN_ITEMEXPANDED:
+            // the item is not refreshed properly after expansion when it has
+            // an image depending on the expanded/collapsed state - bug in
+            // comctl32.dll or our code?
+            {
+                NM_TREEVIEW* tv = (NM_TREEVIEW *)lParam;
+                wxTreeItemId id(tv->itemNew.hItem);
+
+                int image = GetItemImage(id, wxTreeItemIcon_Expanded);
+                if ( image != -1 )
+                {
+                    RefreshItem(id);
+                }
+            }
+            break;
+

         case TVN_GETDISPINFO:
             // NB: so far the user can't set the image himself anyhow, so do it
             //     anyway - but this may change later
         case TVN_GETDISPINFO:
             // NB: so far the user can't set the image himself anyhow, so do it
             //     anyway - but this may change later

-//          if ( /* !processed && */ 1 )
+            //if ( /* !processed && */ 1 )

             {
                 wxTreeItemId item = event.m_item;
                 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
             {
                 wxTreeItemId item = event.m_item;
                 TV_DISPINFO *info = (TV_DISPINFO *)lParam;


@@ -2404,7 +2925,7 @@ bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
                                           : wxTreeItemIcon_Selected
                         );
                 }
                                           : wxTreeItemIcon_Selected
                         );
                 }

-                       }
+            }

             break;
 
         //default:
             break;
 
         //default:


@@ -2414,6 +2935,48 @@ bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
     return processed;
 }
 
     return processed;
 }
 

-#endif // __WIN95__
+// ----------------------------------------------------------------------------
+// State control.
+// ----------------------------------------------------------------------------
+
+// why do they define INDEXTOSTATEIMAGEMASK but not the inverse?
+#define STATEIMAGEMASKTOINDEX(state) (((state) & TVIS_STATEIMAGEMASK) >> 12)
+
+void wxTreeCtrl::SetState(const wxTreeItemId& node, int state)
+{
+    TV_ITEM tvi;
+    tvi.hItem = (HTREEITEM)node.m_pItem;
+    tvi.mask = TVIF_STATE;
+    tvi.stateMask = TVIS_STATEIMAGEMASK;
+
+    // Select the specified state, or -1 == cycle to the next one.
+    if ( state == -1 )
+    {
+        TreeView_GetItem(GetHwnd(), &tvi);
+
+        state = STATEIMAGEMASKTOINDEX(tvi.state) + 1;
+        if ( state == m_imageListState->GetImageCount() )
+            state = 1;
+    }
+
+    wxCHECK_RET( state < m_imageListState->GetImageCount(),
+                 _T("wxTreeCtrl::SetState(): item index out of bounds") );
+
+    tvi.state = INDEXTOSTATEIMAGEMASK(state);
+
+    TreeView_SetItem(GetHwnd(), &tvi);
+}
+
+int wxTreeCtrl::GetState(const wxTreeItemId& node)
+{
+    TV_ITEM tvi;
+    tvi.hItem = (HTREEITEM)node.m_pItem;
+    tvi.mask = TVIF_STATE;
+    tvi.stateMask = TVIS_STATEIMAGEMASK;
+    TreeView_GetItem(GetHwnd(), &tvi);
+
+    return STATEIMAGEMASKTOINDEX(tvi.state);
+}

 
 #endif // wxUSE_TREECTRL
 
 #endif // wxUSE_TREECTRL

+