Compilaton fixes.

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

diff --git a/src/msw/treectrl.cpp b/src/msw/treectrl.cpp
index bf062b711525f11eeb4cf5f121b9022ddbe7906c..f64ea0651cd290856d61564686018d0dde566902 100644 (file)
--- a/src/msw/treectrl.cpp
+++ b/src/msw/treectrl.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        treectrl.cpp
+// Name:        src/msw/treectrl.cpp

 // Purpose:     wxTreeCtrl
 // Author:      Julian Smart
 // Modified by: Vadim Zeitlin to be less MSW-specific on 10.10.98
 // Purpose:     wxTreeCtrl
 // Author:      Julian Smart
 // Modified by: Vadim Zeitlin to be less MSW-specific on 10.10.98


@@ -16,6 +16,7 @@
 // ----------------------------------------------------------------------------
 // headers
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // headers
 // ----------------------------------------------------------------------------

+

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


@@ -27,32 +28,27 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 

-#include "wx/msw/private.h"
-
-// Mingw32 is a bit mental even though this is done in winundef
-#ifdef GetFirstChild
-    #undef GetFirstChild
-#endif
+#if wxUSE_TREECTRL

 
 

-#ifdef GetNextSibling
-    #undef GetNextSibling
-#endif
+#include "wx/msw/private.h"

 
 

-#if defined(__WIN95__)
+// Set this to 1 to be _absolutely_ sure that repainting will work for all
+// comctl32.dll versions
+#define wxUSE_COMCTL32_SAFELY 0

 
 

+#include "wx/app.h"

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

-#include "wx/treectrl.h"

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

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

 #include "wx/msw/dragimag.h"
 
 #ifdef __GNUWIN32_OLD__
     #include "wx/msw/gnuwin32/extra.h"
 #endif
 
 #include "wx/msw/dragimag.h"
 
 #ifdef __GNUWIN32_OLD__
     #include "wx/msw/gnuwin32/extra.h"
 #endif
 

-#if defined(__WIN95__) && !(defined(__GNUWIN32_OLD__) || defined(__TWIN32__))
+#if defined(__WIN95__) && !(defined(__GNUWIN32_OLD__) && !defined(__CYGWIN10__))

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


@@ -69,14 +65,24 @@
     #define TVS_CHECKBOXES          0x0100
 #endif
 
     #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
 
 // 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)
+// macros to hide the cast ugliness
+// --------------------------------
+
+// ptr is the real item id, i.e. wxTreeItemId::m_pItem
+#define HITEM_PTR(ptr)     (HTREEITEM)(ptr)
+
+// 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 +103,6 @@ static HTREEITEM GetItemFromPoint(HWND hwndTV, int x, int y)
     tvht.pt.x = x;
     tvht.pt.y = y;
 
     tvht.pt.x = x;
     tvht.pt.y = y;
 

-    // TreeView_HitTest() doesn't do the right cast in mingw32 headers

     return (HTREEITEM)TreeView_HitTest(hwndTV, &tvht);
 }
 
     return (HTREEITEM)TreeView_HitTest(hwndTV, &tvht);
 }
 


@@ -106,6 +111,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;


@@ -113,13 +119,13 @@ static bool IsItemSelected(HWND hwndTV, HTREEITEM hItem)
 
     if ( !TreeView_GetItem(hwndTV, &tvi) )
     {
 
     if ( !TreeView_GetItem(hwndTV, &tvi) )
     {

-        wxLogLastError("TreeView_GetItem");
+        wxLogLastError(wxT("TreeView_GetItem"));

     }
 
     return (tvi.state & TVIS_SELECTED) != 0;
 }
 
     }
 
     return (tvi.state & TVIS_SELECTED) != 0;
 }
 

-static void SelectItem(HWND hwndTV, HTREEITEM hItem, bool select = TRUE)
+static void 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;


@@ -129,13 +135,13 @@ static void SelectItem(HWND hwndTV, HTREEITEM hItem, bool select = TRUE)
 
     if ( TreeView_SetItem(hwndTV, &tvi) == -1 )
     {
 
     if ( TreeView_SetItem(hwndTV, &tvi) == -1 )
     {

-        wxLogLastError("TreeView_SetItem");
+        wxLogLastError(wxT("TreeView_SetItem"));

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


@@ -148,11 +154,11 @@ 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;
-    HTREEITEM htItem = TreeView_GetRoot(hwndTV);
+    bool cont = true;
+    HTREEITEM htItem = (HTREEITEM)TreeView_GetRoot(hwndTV);

     while ( htItem && cont )
     {
         if ( (htItem == htFirst) || (htItem == htLast) )
     while ( htItem && cont )
     {
         if ( (htItem == htFirst) || (htItem == htLast) )


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

-            cont = FALSE;
+            cont = false;

         }
         else
         {
         }
         else
         {


@@ -172,7 +178,7 @@ static void SelectRange(HWND hwndTV,
             }
         }
 
             }
         }
 

-        htItem = TreeView_GetNextVisible(hwndTV, htItem);
+        htItem = (HTREEITEM)TreeView_GetNextVisible(hwndTV, htItem);

     }
 
     // select the items in range
     }
 
     // select the items in range


@@ -186,7 +192,7 @@ static void SelectRange(HWND hwndTV,
 
         cont = (htItem != htFirst) && (htItem != htLast);
 
 
         cont = (htItem != htFirst) && (htItem != htLast);
 

-        htItem = TreeView_GetNextVisible(hwndTV, htItem);
+        htItem = (HTREEITEM)TreeView_GetNextVisible(hwndTV, htItem);

     }
 
     // unselect the rest
     }
 
     // unselect the rest


@@ -199,7 +205,7 @@ static void SelectRange(HWND hwndTV,
                 UnselectItem(hwndTV, htItem);
             }
 
                 UnselectItem(hwndTV, htItem);
             }
 

-            htItem = TreeView_GetNextVisible(hwndTV, htItem);
+            htItem = (HTREEITEM)TreeView_GetNextVisible(hwndTV, htItem);

         }
     }
 
         }
     }
 


@@ -214,7 +220,7 @@ static void SelectRange(HWND hwndTV,
 static void SetFocus(HWND hwndTV, HTREEITEM htItem)
 {
     // the current focus
 static void SetFocus(HWND hwndTV, HTREEITEM htItem)
 {
     // the current focus

-    HTREEITEM htFocus = TreeView_GetSelection(hwndTV);
+    HTREEITEM htFocus = (HTREEITEM)TreeView_GetSelection(hwndTV);

 
     if ( htItem )
     {
 
     if ( htItem )
     {


@@ -281,6 +287,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_;


@@ -288,12 +296,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:


@@ -303,12 +342,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:


@@ -318,6 +357,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


@@ -335,6 +376,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


@@ -344,7 +391,7 @@ public:
             m_selections.Add(item);
         }
 
             m_selections.Add(item);
         }
 

-        return TRUE;
+        return true;

     }
 
     size_t GetCount() const { return m_selections.GetCount(); }
     }
 
     size_t GetCount() const { return m_selections.GetCount(); }


@@ -367,11 +414,11 @@ public:
             DoTraverse(root, recursively);
         }
 
             DoTraverse(root, recursively);
         }
 

-    virtual bool OnVisit(const wxTreeItemId& item)
+    virtual bool OnVisit(const wxTreeItemId& WXUNUSED(item))

     {
         m_count++;
 
     {
         m_count++;
 

-        return TRUE;
+        return true;

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


@@ -390,11 +437,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


@@ -411,10 +459,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


@@ -433,7 +484,10 @@ 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)

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


@@ -443,15 +497,36 @@ private:
 IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxControl)
 
 // ----------------------------------------------------------------------------
 IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxControl)
 
 // ----------------------------------------------------------------------------

-// variables
+// constants

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

-// handy table for sending events
-static const 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


@@ -464,28 +539,28 @@ static const 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;

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


@@ -496,11 +571,18 @@ void wxTreeCtrl::Init()
 {
     m_imageListNormal = NULL;
     m_imageListState = NULL;
 {
     m_imageListNormal = NULL;
     m_imageListState = NULL;

+    m_ownsImageListNormal = m_ownsImageListState = false;

     m_textCtrl = NULL;
     m_textCtrl = NULL;

-    m_hasAnyAttr = FALSE;
+    m_hasAnyAttr = false;

     m_dragImage = NULL;
     m_dragImage = NULL;

+    m_pVirtualRoot = NULL;

 
 

-    m_htSelStart = 0;
+    // 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,


@@ -513,12 +595,18 @@ bool wxTreeCtrl::Create(wxWindow *parent,
 {
     Init();
 
 {
     Init();
 

+    if ( (style & wxBORDER_MASK) == wxBORDER_DEFAULT )
+        style |= wxBORDER_SUNKEN;
+

     if ( !CreateControl(parent, id, pos, size, style, validator, name) )
     if ( !CreateControl(parent, id, pos, size, style, validator, name) )

-        return FALSE;
+        return false;

 
 

-    DWORD wstyle = WS_VISIBLE | WS_CHILD | WS_TABSTOP |
-                   TVS_HASLINES | TVS_SHOWSELALWAYS;
+    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_HAS_BUTTONS )
         wstyle |= TVS_HASBUTTONS;
 
     if ( m_windowStyle & wxTR_HAS_BUTTONS )
         wstyle |= TVS_HASBUTTONS;
 


@@ -528,6 +616,12 @@ 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 ( 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 && \


@@ -544,10 +638,25 @@ bool wxTreeCtrl::Create(wxWindow *parent,
 
     // Create the tree control.
     if ( !MSWCreateControl(WC_TREEVIEW, wstyle) )
 
     // Create the tree control.
     if ( !MSWCreateControl(WC_TREEVIEW, wstyle) )

-        return FALSE;
+        return false;

 
 

-    SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
+#if wxUSE_COMCTL32_SAFELY
+    wxWindow::SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
+    wxWindow::SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
+#elif 1
+    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
+    // of comctrl32, setting any colour actually draws the background in black.
+    // This will initialise the background to the system colour.
+    // 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::GetColour(wxSYS_COLOUR_WINDOW));

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

+#endif
+

 
     // VZ: this is some experimental code which may be used to get the
     //     TVS_CHECKBOXES style functionality for comctl32.dll < 4.71.
 
     // VZ: this is some experimental code which may be used to get the
     //     TVS_CHECKBOXES style functionality for comctl32.dll < 4.71.


@@ -563,7 +672,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


@@ -602,7 +711,7 @@ 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;
+    return true;

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


@@ -610,19 +719,20 @@ 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();
     DeleteAllItems();

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

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


@@ -633,21 +743,24 @@ wxTreeCtrl::~wxTreeCtrl()
 
 bool wxTreeCtrl::DoGetItem(wxTreeViewItem* tvItem) const
 {
 
 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) )
     {
     if ( !TreeView_GetItem(GetHwnd(), tvItem) )
     {

-        wxLogLastError("TreeView_GetItem");
+        wxLogLastError(wxT("TreeView_GetItem"));

 
 

-        return FALSE;
+        return false;

     }
 
     }
 

-    return TRUE;
+    return true;

 }
 
 void wxTreeCtrl::DoSetItem(wxTreeViewItem* tvItem)
 {
     if ( TreeView_SetItem(GetHwnd(), tvItem) == -1 )
     {
 }
 
 void wxTreeCtrl::DoSetItem(wxTreeViewItem* tvItem)
 {
     if ( TreeView_SetItem(GetHwnd(), tvItem) == -1 )
     {

-        wxLogLastError("TreeView_SetItem");
+        wxLogLastError(wxT("TreeView_SetItem"));

     }
 }
 
     }
 }
 


@@ -673,7 +786,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)


@@ -686,12 +799,30 @@ void wxTreeCtrl::SetAnyImageList(wxImageList *imageList, int which)
 
 void wxTreeCtrl::SetImageList(wxImageList *imageList)
 {
 
 void wxTreeCtrl::SetImageList(wxImageList *imageList)
 {

+    if (m_ownsImageListNormal)
+        delete m_imageListNormal;
+

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

+    m_ownsImageListNormal = false;

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

+    if (m_ownsImageListState) delete m_imageListState;

     SetAnyImageList(m_imageListState = imageList, TVSIL_STATE);
     SetAnyImageList(m_imageListState = imageList, TVSIL_STATE);

+    m_ownsImageListState = false;
+}
+
+void wxTreeCtrl::AssignImageList(wxImageList *imageList)
+{
+    SetImageList(imageList);
+    m_ownsImageListNormal = true;
+}
+
+void wxTreeCtrl::AssignStateImageList(wxImageList *imageList)
+{
+    SetStateImageList(imageList);
+    m_ownsImageListState = true;

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


@@ -708,22 +839,26 @@ size_t wxTreeCtrl::GetChildrenCount(const wxTreeItemId& item,
 
 bool wxTreeCtrl::SetBackgroundColour(const wxColour &colour)
 {
 
 bool wxTreeCtrl::SetBackgroundColour(const wxColour &colour)
 {

+#if !wxUSE_COMCTL32_SAFELY

     if ( !wxWindowBase::SetBackgroundColour(colour) )
     if ( !wxWindowBase::SetBackgroundColour(colour) )

-        return FALSE;
+        return false;

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

+#endif

 
 

-    return TRUE;
+    return true;

 }
 
 bool wxTreeCtrl::SetForegroundColour(const wxColour &colour)
 {
 }
 
 bool wxTreeCtrl::SetForegroundColour(const wxColour &colour)
 {

+#if !wxUSE_COMCTL32_SAFELY

     if ( !wxWindowBase::SetForegroundColour(colour) )
     if ( !wxWindowBase::SetForegroundColour(colour) )

-        return FALSE;
+        return false;

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

+#endif

 
 

-    return TRUE;
+    return true;

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


@@ -748,9 +883,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,


@@ -806,6 +958,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);


@@ -839,15 +997,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:


@@ -863,7 +1041,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


@@ -892,23 +1070,41 @@ 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 )
+    {
+        data->SetId(item);
+    }
+

     wxTreeViewItem tvItem(item, TVIF_PARAM);
 
     if ( HasIndirectData(item) )
     wxTreeViewItem tvItem(item, TVIF_PARAM);
 
     if ( HasIndirectData(item) )


@@ -938,18 +1134,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);


@@ -957,6 +1163,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);


@@ -964,56 +1173,110 @@ 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);
 }
 

+void wxTreeCtrl::RefreshItem(const wxTreeItemId& item)
+{
+    if ( IS_VIRTUAL_ROOT(item) )
+        return;
+
+    wxRect rect;
+    if ( GetBoundingRect(item, rect) )
+    {
+        RefreshRect(rect);
+    }
+}
+
+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);

+
+    RefreshItem(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);

+
+    RefreshItem(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);

+
+    RefreshItem(item);

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


@@ -1022,16 +1285,21 @@ 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;
-
-    // FALSE means get item rect for the whole item, not only text
-    return SendMessage(GetHwnd(), TVM_GETITEMRECT, FALSE, (LPARAM)&rect) != 0;
+    *(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;

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


@@ -1075,45 +1343,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), (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 item;
+}
+
+#if WXWIN_COMPATIBILITY_2_4
+
+wxTreeItemId wxTreeCtrl::GetFirstChild(const wxTreeItemId& item,
+                                       long& cookie) const
+{
+    cookie = (long)TreeView_GetChild(GetHwnd(), HITEM(item));

 
 

-    return wxTreeItemId((WXHTREEITEM)_cookie);
+    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);


@@ -1128,33 +1442,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
 {
 }
 
 wxTreeItemId wxTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
 {

-    wxASSERT_MSG( IsVisible(item), wxT("The item you call GetNextVisible() "
-                                      "for must be visible itself!"));
+    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
 {
 }
 
 wxTreeItemId wxTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
 {

-    wxASSERT_MSG( IsVisible(item), wxT("The item you call GetPrevVisible() "
-                                      "for must be visible itself!"));
+    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)));

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


@@ -1176,6 +1488,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;
 


@@ -1199,6 +1513,10 @@ wxTreeItemId wxTreeCtrl::DoInsertItem(const wxTreeItemId& parent,
                                       int image, int selectedImage,
                                       wxTreeItemData *data)
 {
                                       int image, int selectedImage,
                                       wxTreeItemData *data)
 {

+    wxCHECK_MSG( parent.IsOk() || !TreeView_GetRoot(GetHwnd()),
+                 wxTreeItemId(),
+                 _T("can't have more than one root in the tree") );
+

     TV_INSERTSTRUCT tvIns;
     tvIns.hParent = HITEM(parent);
     tvIns.hInsertAfter = HITEM(hInsertAfter);
     TV_INSERTSTRUCT tvIns;
     tvIns.hParent = HITEM(parent);
     tvIns.hInsertAfter = HITEM(hInsertAfter);


@@ -1216,6 +1534,11 @@ wxTreeItemId wxTreeCtrl::DoInsertItem(const wxTreeItemId& parent,
         mask |= TVIF_TEXT;
         tvIns.item.pszText = (wxChar *)text.c_str();  // cast is ok
     }
         mask |= TVIF_TEXT;
         tvIns.item.pszText = (wxChar *)text.c_str();  // cast is ok
     }

+    else
+    {
+        tvIns.item.pszText = NULL;
+        tvIns.item.cchTextMax = 0;
+    }

 
     if ( image != -1 )
     {
 
     if ( image != -1 )
     {


@@ -1246,33 +1569,46 @@ wxTreeItemId wxTreeCtrl::DoInsertItem(const wxTreeItemId& parent,
     HTREEITEM id = (HTREEITEM) TreeView_InsertItem(GetHwnd(), &tvIns);
     if ( id == 0 )
     {
     HTREEITEM id = (HTREEITEM) TreeView_InsertItem(GetHwnd(), &tvIns);
     if ( id == 0 )
     {

-        wxLogLastError("TreeView_InsertItem");
+        wxLogLastError(wxT("TreeView_InsertItem"));

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


@@ -1281,7 +1617,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);
 }
 


@@ -1301,7 +1637,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() )
     {


@@ -1323,7 +1659,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);
 }
 


@@ -1331,20 +1667,20 @@ void wxTreeCtrl::Delete(const wxTreeItemId& item)
 {
     if ( !TreeView_DeleteItem(GetHwnd(), HITEM(item)) )
     {
 {
     if ( !TreeView_DeleteItem(GetHwnd(), HITEM(item)) )
     {

-        wxLogLastError("TreeView_DeleteItem");
+        wxLogLastError(wxT("TreeView_DeleteItem"));

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


@@ -1352,18 +1688,27 @@ 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("TreeView_DeleteItem");
+            wxLogLastError(wxT("TreeView_DeleteItem"));

         }
     }
 }
 
 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()) )
     {
     if ( !TreeView_DeleteAllItems(GetHwnd()) )
     {

-        wxLogLastError("TreeView_DeleteAllItems");
+        wxLogLastError(wxT("TreeView_DeleteAllItems"));

     }
 }
 
     }
 }
 


@@ -1375,6 +1720,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


@@ -1391,17 +1740,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
 }


@@ -1426,10 +1773,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()
 {


@@ -1437,7 +1786,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((WXHTREEITEM) 0));
+    SelectItem(wxTreeItemId());

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


@@ -1449,9 +1798,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
         }
     }


@@ -1488,7 +1837,7 @@ void wxTreeCtrl::SelectItem(const wxTreeItemId& item)
         {
             if ( !TreeView_SelectItem(GetHwnd(), HITEM(item)) )
             {
         {
             if ( !TreeView_SelectItem(GetHwnd(), HITEM(item)) )
             {

-                wxLogLastError("TreeView_SelectItem");
+                wxLogLastError(wxT("TreeView_SelectItem"));

             }
             else
             {
             }
             else
             {


@@ -1510,30 +1859,12 @@ void wxTreeCtrl::ScrollTo(const wxTreeItemId& item)
 {
     if ( !TreeView_SelectSetFirstVisible(GetHwnd(), HITEM(item)) )
     {
 {
     if ( !TreeView_SelectSetFirstVisible(GetHwnd(), HITEM(item)) )
     {

-        wxLogLastError("TreeView_SelectSetFirstVisible");
+        wxLogLastError(wxT("TreeView_SelectSetFirstVisible"));

     }
 }
 
     }
 }
 

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


@@ -1541,6 +1872,14 @@ void wxTreeCtrl::DeleteTextCtrl()
 {
     if ( m_textCtrl )
     {
 {
     if ( m_textCtrl )
     {

+        // the HWND corresponding to this control is deleted by the tree
+        // control itself and we don't know when exactly this happens, so check
+        // if the window still exists before calling UnsubclassWin()
+        if ( !::IsWindow(GetHwndOf(m_textCtrl)) )
+        {
+            m_textCtrl->SetHWND(0);
+        }
+

         m_textCtrl->UnsubclassWin();
         m_textCtrl->SetHWND(0);
         delete m_textCtrl;
         m_textCtrl->UnsubclassWin();
         m_textCtrl->SetHWND(0);
         delete m_textCtrl;


@@ -1555,24 +1894,24 @@ 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->SetHWND((WXHWND)hWnd);
-    m_textCtrl->SubclassWin((WXHWND)hWnd);
-
+    // textctrl is subclassed in MSWOnNotify

     return m_textCtrl;
 }
 
 // End label editing, optionally cancelling the edit
     return m_textCtrl;
 }
 
 // End label editing, optionally cancelling the edit

-void wxTreeCtrl::EndEditLabel(const wxTreeItemId& item, bool discardChanges)
+void wxTreeCtrl::EndEditLabel(const wxTreeItemId& WXUNUSED(item), bool discardChanges)

 {
     TreeView_EndEditLabelNow(GetHwnd(), discardChanges);
 
 {
     TreeView_EndEditLabelNow(GetHwnd(), discardChanges);
 


@@ -1607,7 +1946,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,


@@ -1615,17 +1954,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;

     }
 }
 
     }
 }
 


@@ -1633,14 +1979,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,


@@ -1662,7 +2031,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 */);
     }


@@ -1689,11 +2058,11 @@ 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
 }
 
 // we hook into WndProc to process WM_MOUSEMOVE/WM_BUTTONUP messages - as we


@@ -1702,21 +2071,35 @@ bool wxTreeCtrl::MSWCommand(WXUINT cmd, WXWORD id)
 // instead of passing by wxWin events
 long wxTreeCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
 {
 // instead of passing by wxWin events
 long wxTreeCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
 {

-    bool processed = FALSE;
+    bool processed = false;

     long rc = 0;
     long 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 select, remove the entire
+                // previous selection
+                if (!::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 )


@@ -1731,9 +2114,9 @@ long wxTreeCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
                         ::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 )
                     {


@@ -1743,8 +2126,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,


@@ -1752,20 +2134,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.
+                            
+                            if (IsItemSelected(GetHwnd(), htItem))
+                            {
+                                ::SetFocus(GetHwnd(), htItem);
+                            }
+                             else
+                            {
+                                UnselectAll();

 
 

-                        // prevent the click from starting in-place editing
-                        // when there was no selection in the control
-                        TreeView_SelectItem(GetHwnd(), 0);
+                                // 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;


@@ -1787,6 +2193,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 )
                 {


@@ -1797,7 +2221,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);
 


@@ -1821,12 +2245,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);

             }
         }
     }
             }
         }
     }


@@ -1838,10 +2262,10 @@ long wxTreeCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
         // we handle.arrows and space, but not page up/down and home/end: the
         // latter should be easy, but not the former
 
         // we handle.arrows and space, but not page up/down and home/end: the
         // latter should be easy, but not the former
 

-        HTREEITEM htSel = TreeView_GetSelection(GetHwnd());
+        HTREEITEM htSel = (HTREEITEM)TreeView_GetSelection(GetHwnd());

         if ( !m_htSelStart )
         {
         if ( !m_htSelStart )
         {

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

         }
 
         if ( wParam == VK_SPACE )
         }
 
         if ( wParam == VK_SPACE )


@@ -1857,7 +2281,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 )
         {


@@ -1871,9 +2295,9 @@ long wxTreeCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
             {
                 (void)wxControl::MSWWindowProc(nMsg, wParam, lParam);
 
             {
                 (void)wxControl::MSWWindowProc(nMsg, wParam, lParam);
 

-                HTREEITEM htNext =
-                    wParam == VK_UP ? TreeView_GetPrevVisible(GetHwnd(), htSel)
-                                    : TreeView_GetNextVisible(GetHwnd(), htSel);
+                HTREEITEM htNext = (HTREEITEM)(wParam == VK_UP
+                                    ? TreeView_GetPrevVisible(GetHwnd(), htSel)
+                                    : TreeView_GetNextVisible(GetHwnd(), htSel));

 
                 if ( !htNext )
                 {
 
                 if ( !htNext )
                 {


@@ -1891,11 +2315,23 @@ 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);


@@ -1912,25 +2348,6 @@ bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
 
     switch ( hdr->code )
     {
 
     switch ( hdr->code )
     {

-        case NM_RCLICK:
-            {
-                if ( wxControl::MSWOnNotify(idCtrl, lParam, result) )
-                    return TRUE;
-
-                TV_HITTESTINFO tvhti;
-                ::GetCursorPos(&(tvhti.pt));
-                ::ScreenToClient(GetHwnd(),&(tvhti.pt));
-                if ( TreeView_HitTest(GetHwnd(),&tvhti) )
-                {
-                    if( tvhti.flags & TVHT_ONITEM )
-                    {
-                        event.m_item = (WXHTREEITEM) tvhti.hItem;
-                        eventType = wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK;
-                    }
-                }
-            }
-            break;
-

         case TVN_BEGINDRAG:
             eventType = wxEVT_COMMAND_TREE_BEGIN_DRAG;
             // fall through
         case TVN_BEGINDRAG:
             eventType = wxEVT_COMMAND_TREE_BEGIN_DRAG;
             // fall through


@@ -1943,7 +2360,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


@@ -1958,8 +2375,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;
 


@@ -1968,12 +2386,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;


@@ -1983,10 +2405,16 @@ 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;
                 if (info->item.pszText == NULL)
                 event.m_label = info->item.pszText;
                 if (info->item.pszText == NULL)

-                    return FALSE;
+                {
+                    event.m_editCancelled = true;
+                }
+                 else
+                {
+                    event.m_editCancelled = false;
+                }

                 break;
             }
 
                 break;
             }
 


@@ -2002,38 +2430,37 @@ 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;
             }
 
         case TVN_ITEMEXPANDING:
                 break;
             }
 
         case TVN_ITEMEXPANDING:

-            event.m_code = FALSE;
-            // fall through
-

         case TVN_ITEMEXPANDED:
             {
                 NM_TREEVIEW* tv = (NM_TREEVIEW*)lParam;
 
         case TVN_ITEMEXPANDED:
             {
                 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;
+
+                eventType = gs_expandEvents[what][how];

 
 

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

             }
             break;
 
             }
             break;
 


@@ -2042,7 +2469,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;
 

-                event.m_code = wxCharCodeMSWToWX(info->wVKey);
+                // 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,
+                                                keyCode,
+                                                lParam,
+                                                wParam);

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


@@ -2062,60 +2508,76 @@ 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
+#if defined(_WIN32_IE) && _WIN32_IE >= 0x300 && !wxUSE_COMCTL32_SAFELY && !( defined(__GNUWIN32__) && !wxCHECK_W32API_VERSION( 1, 0 ) )

         case NM_CUSTOMDRAW:
             {
                 LPNMTVCUSTOMDRAW lptvcd = (LPNMTVCUSTOMDRAW)lParam;
                 NMCUSTOMDRAW& nmcd = lptvcd->nmcd;
         case NM_CUSTOMDRAW:
             {
                 LPNMTVCUSTOMDRAW lptvcd = (LPNMTVCUSTOMDRAW)lParam;
                 NMCUSTOMDRAW& nmcd = lptvcd->nmcd;

-                switch( nmcd.dwDrawStage )
+                switch ( nmcd.dwDrawStage )

                 {
                     case CDDS_PREPAINT:
                         // if we've got any items with non standard attributes,
                         // notify us before painting each item
                         *result = m_hasAnyAttr ? CDRF_NOTIFYITEMDRAW
                                                : CDRF_DODEFAULT;
                 {
                     case CDDS_PREPAINT:
                         // if we've got any items with non standard attributes,
                         // notify us before painting each item
                         *result = m_hasAnyAttr ? CDRF_NOTIFYITEMDRAW
                                                : CDRF_DODEFAULT;

-                        return TRUE;
+                        break;

 
                     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
                             {
                                 // nothing to do for this item

-                                return CDRF_DODEFAULT;
+                                *result = CDRF_DODEFAULT;
+                                break;

                             }
 
                             }
 

+                            wxTreeItemAttr * const attr = it->second;
+

                             HFONT hFont;
                             HFONT hFont;

-                            wxColour colText, colBack;

                             if ( attr->HasFont() )
                             {
                             if ( attr->HasFont() )
                             {

-                                wxFont font = attr->GetFont();
-                                hFont = (HFONT)font.GetResourceHandle();
+                                hFont = GetHfontOf(attr->GetFont());

                             }
                             else
                             {
                                 hFont = 0;
                             }
 
                             }
                             else
                             {
                                 hFont = 0;
                             }
 

+                            wxColour colText;

                             if ( attr->HasTextColour() )
                             {
                                 colText = attr->GetTextColour();
                             if ( attr->HasTextColour() )
                             {
                                 colText = attr->GetTextColour();


@@ -2128,16 +2590,14 @@ bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
                             // selection colours should override ours
                             if ( nmcd.uItemState & CDIS_SELECTED )
                             {
                             // 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;
+                                lptvcd->clrTextBk =
+                                    ::GetSysColor(COLOR_HIGHLIGHT);
+                                lptvcd->clrText =
+                                    ::GetSysColor(COLOR_HIGHLIGHTTEXT);

                             }
                             }

-                            else
+                            else // !selected

                             {
                             {

+                                wxColour colBack;

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


@@ -2164,18 +2624,59 @@ bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
                             {
                                 *result = CDRF_DODEFAULT;
                             }
                             {
                                 *result = CDRF_DODEFAULT;
                             }

-
-                            return TRUE;

                         }
                         }

+                        break;

 
                     default:
                         *result = CDRF_DODEFAULT;
 
                     default:
                         *result = CDRF_DODEFAULT;

-                        return TRUE;

                 }
             }
                 }
             }

-            break;
+
+            // we always process it
+            return true;

 #endif // _WIN32_IE >= 0x300
 
 #endif // _WIN32_IE >= 0x300
 

+        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:
+            {
+                TV_HITTESTINFO tvhti;
+                ::GetCursorPos(&tvhti.pt);
+                ::ScreenToClient(GetHwnd(), &tvhti.pt);
+                if ( TreeView_HitTest(GetHwnd(), &tvhti) )
+                {
+                    if ( tvhti.flags & TVHT_ONITEM )
+                    {
+                        event.m_item = tvhti.hItem;
+                        eventType = (int)hdr->code == NM_DBLCLK
+                                    ? wxEVT_COMMAND_TREE_ITEM_ACTIVATED
+                                    : wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK;
+
+                        event.m_pointDrag.x = tvhti.pt.x;
+                        event.m_pointDrag.y = tvhti.pt.y;
+                    }
+
+                    break;
+                }
+            }
+            // fall through
+

         default:
             return wxControl::MSWOnNotify(idCtrl, lParam, result);
     }
         default:
             return wxControl::MSWOnNotify(idCtrl, lParam, result);
     }


@@ -2188,6 +2689,14 @@ bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
     // post processing
     switch ( hdr->code )
     {
     // post processing
     switch ( hdr->code )
     {

+        case NM_DBLCLK:
+            // we translate NM_DBLCLK into ACTIVATED event, so don't interpret
+            // 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;
+            break;
+

         case TVN_BEGINDRAG:
         case TVN_BEGINRDRAG:
             if ( event.IsAllowed() )
         case TVN_BEGINDRAG:
         case TVN_BEGINRDRAG:
             if ( event.IsAllowed() )


@@ -2216,8 +2725,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);

                 }
                 else
                 {
                 }
                 else
                 {


@@ -2225,18 +2732,48 @@ 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
+            // 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
+            // to be passed to DefWindowProc() which will happily return false
+            // cancelling the label change

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

+            processed = true;

 
             // ensure that we don't have the text ctrl which is going to be
             // deleted any more
 
             // ensure that we don't have the text ctrl which is going to be
             // deleted any more


@@ -2245,14 +2782,30 @@ bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
 
         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;


@@ -2283,22 +2836,51 @@ bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
             // for the other messages the return value is ignored and there is
             // nothing special to do
     }
             // for the other messages the return value is ignored and there is
             // nothing special to do
     }

-

     return processed;
 }
 
 // ----------------------------------------------------------------------------
     return processed;
 }
 
 // ----------------------------------------------------------------------------

-// Tree event
+// State control.

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

-IMPLEMENT_DYNAMIC_CLASS(wxTreeEvent, wxNotifyEvent)
+// why do they define INDEXTOSTATEIMAGEMASK but not the inverse?
+#define STATEIMAGEMASKTOINDEX(state) (((state) & TVIS_STATEIMAGEMASK) >> 12)

 
 

-wxTreeEvent::wxTreeEvent(wxEventType commandType, int id)
-           : wxNotifyEvent(commandType, id)
+void wxTreeCtrl::SetState(const wxTreeItemId& node, int state)

 {
 {

-    m_code = 0;
-    m_itemOld = 0;
+    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 // __WIN95__
+#endif // wxUSE_TREECTRL