]> git.saurik.com Git - wxWidgets.git/blobdiff - src/os2/treectrl.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
some conflicts resolved
[wxWidgets.git] / src / os2 / treectrl.cpp
diff --git a/src/os2/treectrl.cpp b/src/os2/treectrl.cpp
index 137a885dbfa7e32c9096f78376146fda7cffaf68..8671b38c71030beedf1894bdeef675da04f76c82 100644 (file)
--- a/src/os2/treectrl.cpp
+++ b/src/os2/treectrl.cpp
@@ -1,418 +1,1689 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        treectrl.cpp
 // Purpose:     wxTreeCtrl. See also Robert's generic wxTreeCtrl.
 /////////////////////////////////////////////////////////////////////////////
 // Name:        treectrl.cpp
 // Purpose:     wxTreeCtrl. See also Robert's generic wxTreeCtrl.
-// Author:      AUTHOR
+// Author:      David Webster
 // Modified by:
 // Modified by:
-// Created:     ??/??/98
+// Created:     10/17/99
 // RCS-ID:      $Id$
 // RCS-ID:      $Id$
-// Copyright:   (c) AUTHOR
-// Licence:    wxWindows licence
+// Copyright:   (c) David
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
 
-#ifdef __GNUG__
-#pragma implementation "treectrl.h"
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#include "wx/window.h"
+#include "wx/os2/private.h"
+
+#include "wx/log.h"
+#include "wx/dynarray.h"
+#include "wx/imaglist.h"
+#include "wx/treectrl.h"
+#include "wx/settings.h"
+
+// Bug in headers, sometimes
+#ifndef TVIS_FOCUSED
+    #define TVIS_FOCUSED            0x0001
 #endif
 
 #endif
 
-#include "wx/stubs/textctrl.h"
-#include "wx/stubs/treectrl.h"
+// ----------------------------------------------------------------------------
+// private classes
+// ----------------------------------------------------------------------------
 
 
-#if !USE_SHARED_LIBRARY
-IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxControl)
-IMPLEMENT_DYNAMIC_CLASS(wxTreeItem, wxObject)
+struct wxTreeViewItem// ??? : public TV_ITEM
+{
+    wxTreeViewItem(const wxTreeItemId& item,    // the item handle
+                   UINT mask_,                  // fields which are valid
+                   UINT stateMask_ = 0)         // for TVIF_STATE only
+    {
+        // hItem member is always valid
+        mask = mask_; // | TVIF_HANDLE;
+        stateMask = stateMask_;
+        hItem = /*(HTREEITEM)*/ (WXHTREEITEM) item;
+    }
+    // OS/2 subs
+    UINT          mask;
+    UINT          stateMask;
+    WXHTREEITEM   hItem;
+};
+
+// a class which encapsulates the tree traversal logic: it vists all (unless
+// OnVisit() returns FALSE) items under the given one
+class wxTreeTraversal
+{
+public:
+    wxTreeTraversal(const wxTreeCtrl *tree)
+    {
+        m_tree = tree;
+    }
+
+    // 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);
+
+    // override this function to do whatever is needed for each item, return
+    // FALSE to stop traversing
+    virtual bool OnVisit(const wxTreeItemId& item) = 0;
+
+protected:
+    const wxTreeCtrl *GetTree() const { return m_tree; }
+
+private:
+    bool Traverse(const wxTreeItemId& root, bool recursively);
+
+    const wxTreeCtrl *m_tree;
+};
+
+// internal class for getting the selected items
+class TraverseSelections : public wxTreeTraversal
+{
+public:
+    TraverseSelections(const wxTreeCtrl *tree,
+                       wxArrayTreeItemIds& selections)
+        : wxTreeTraversal(tree), m_selections(selections)
+        {
+            m_selections.Empty();
+
+            DoTraverse(tree->GetRootItem());
+        }
+
+    virtual bool OnVisit(const wxTreeItemId& item)
+    {
+        if ( GetTree()->IsItemChecked(item) )
+        {
+            m_selections.Add(item);
+        }
+
+        return TRUE;
+    }
 
 
+private:
+    wxArrayTreeItemIds& m_selections;
+};
+
+// internal class for counting tree items
+class TraverseCounter : public wxTreeTraversal
+{
+public:
+    TraverseCounter(const wxTreeCtrl *tree,
+                    const wxTreeItemId& root,
+                    bool recursively)
+        : wxTreeTraversal(tree)
+        {
+            m_count = 0;
+
+            DoTraverse(root, recursively);
+        }
+
+    virtual bool OnVisit(const wxTreeItemId& item)
+    {
+        m_count++;
+
+        return TRUE;
+    }
+
+    size_t GetCount() const { return m_count; }
+
+private:
+    size_t m_count;
+};
+
+// ----------------------------------------------------------------------------
+// This class is needed for support of different images: the Win32 common
+// control natively supports only 2 images (the normal one and another for the
+// selected state). We wish to provide support for 2 more of them for folder
+// items (i.e. those which have children): for expanded state and for expanded
+// selected state. For this we use this structure to store the additional items
+// images.
+//
+// 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.
+// ----------------------------------------------------------------------------
+class wxTreeItemIndirectData
+{
+public:
+    // ctor associates this data with the item and the real item data becomes
+    // available through our GetData() method
+    wxTreeItemIndirectData(wxTreeCtrl *tree, const wxTreeItemId& item)
+    {
+        for ( size_t n = 0; n < WXSIZEOF(m_images); n++ )
+        {
+            m_images[n] = -1;
+        }
+
+        // save the old data
+        m_data = tree->GetItemData(item);
+
+        // and set ourselves as the new one
+        tree->SetIndirectItemData(item, this);
+    }
+
+    // dtor deletes the associated data as well
+    ~wxTreeItemIndirectData() { delete m_data; }
+
+    // accessors
+        // get the real data associated with the item
+    wxTreeItemData *GetData() const { return m_data; }
+        // change it
+    void SetData(wxTreeItemData *data) { m_data = data; }
+
+        // do we have such image?
+    bool HasImage(wxTreeItemIcon which) const { return m_images[which] != -1; }
+        // get image
+    int GetImage(wxTreeItemIcon which) const { return m_images[which]; }
+        // change it
+    void SetImage(int image, wxTreeItemIcon which) { m_images[which] = image; }
+
+private:
+    // all the images associated with the item
+    int m_images[wxTreeItemIcon_Max];
+
+    wxTreeItemData *m_data;
+};
+
+// ----------------------------------------------------------------------------
+// macros
+// ----------------------------------------------------------------------------
+
+#if !USE_SHARED_LIBRARY
+    IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxControl)
 #endif
 
 #endif
 
-wxTreeCtrl::wxTreeCtrl()
+// ----------------------------------------------------------------------------
+// variables
+// ----------------------------------------------------------------------------
+
+// handy table for sending events
+static const wxEventType g_events[2][2] =
 {
 {
-    m_imageListNormal = NULL;
-    m_imageListState = NULL;
-    m_textCtrl = NULL;
+    { wxEVT_COMMAND_TREE_ITEM_COLLAPSED, wxEVT_COMMAND_TREE_ITEM_COLLAPSING },
+    { wxEVT_COMMAND_TREE_ITEM_EXPANDED,  wxEVT_COMMAND_TREE_ITEM_EXPANDING  }
+};
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// tree traversal
+// ----------------------------------------------------------------------------
+
+bool wxTreeTraversal::DoTraverse(const wxTreeItemId& root, bool recursively)
+{
+    if ( !OnVisit(root) )
+        return FALSE;
+
+    return Traverse(root, recursively);
 }
 
 }
 
-bool wxTreeCtrl::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
-            long style, const wxValidator& validator, const wxString& name)
+bool wxTreeTraversal::Traverse(const wxTreeItemId& root, bool recursively)
 {
 {
-    SetName(name);
-    SetValidator(validator);
+    long cookie;
+    wxTreeItemId child = m_tree->GetFirstChild(root, cookie);
+    while ( child.IsOk() )
+    {
+        // depth first traversal
+        if ( recursively && !Traverse(child, TRUE) )
+            return FALSE;
+
+        if ( !OnVisit(child) )
+            return FALSE;
+
+        child = m_tree->GetNextChild(root, cookie);
+    }
 
 
+    return TRUE;
+}
+
+// ----------------------------------------------------------------------------
+// construction and destruction
+// ----------------------------------------------------------------------------
+
+void wxTreeCtrl::Init()
+{
     m_imageListNormal = NULL;
     m_imageListState = NULL;
     m_textCtrl = NULL;
     m_imageListNormal = NULL;
     m_imageListState = NULL;
     m_textCtrl = NULL;
+}
 
 
-    m_windowStyle = style;
+bool wxTreeCtrl::Create(wxWindow *parent,
+                        wxWindowID id,
+                        const wxPoint& pos,
+                        const wxSize& size,
+                        long style,
+                        const wxValidator& validator,
+                        const wxString& name)
+{
+    Init();
+
+    if ( !CreateControl(parent, id, pos, size, style, validator, name) )
+        return FALSE;
+// TODO:
+/*
+    DWORD wstyle = WS_VISIBLE | WS_CHILD | WS_TABSTOP |
+                   TVS_HASLINES | TVS_SHOWSELALWAYS;
+
+    if ( m_windowStyle & wxTR_HAS_BUTTONS )
+        wstyle |= TVS_HASBUTTONS;
+
+    if ( m_windowStyle & wxTR_EDIT_LABELS )
+        wstyle |= TVS_EDITLABELS;
+
+    if ( m_windowStyle & wxTR_LINES_AT_ROOT )
+        wstyle |= TVS_LINESATROOT;
+
+    if ( m_windowStyle & wxTR_MULTIPLE )
+        wstyle |= TVS_CHECKBOXES;
+
+    // Create the tree control.
+    if ( !OS2CreateControl(WC_TREEVIEW, wstyle) )
+        return FALSE;
+*/
+    SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
+    SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
+
+    // VZ: this is some experimental code which may be used to get the
+    //     TVS_CHECKBOXES style functionality for comctl32.dll < 4.71.
+    //     AFAIK, the standard DLL does about the same thing anyhow.
+#if 0
+    if ( m_windowStyle & wxTR_MULTIPLE )
+    {
+        wxBitmap bmp;
+
+        // create the DC compatible with the current screen
+        HDC hdcMem = CreateCompatibleDC(NULL);
+
+        // create a mono bitmap of the standard size
+        int x = GetSystemMetrics(SM_CXMENUCHECK);
+        int y = GetSystemMetrics(SM_CYMENUCHECK);
+        wxImageList imagelistCheckboxes(x, y, FALSE, 2);
+        HBITMAP hbmpCheck = CreateBitmap(x, y,   // bitmap size
+                                         1,      // # of color planes
+                                         1,      // # bits needed for one pixel
+                                         0);     // array containing colour data
+        SelectObject(hdcMem, hbmpCheck);
+
+        // then draw a check mark into it
+        RECT rect = { 0, 0, x, y };
+        if ( !::DrawFrameControl(hdcMem, &rect,
+                                 DFC_BUTTON,
+                                 DFCS_BUTTONCHECK | DFCS_CHECKED) )
+        {
+            wxLogLastError(wxT("DrawFrameControl(check)"));
+        }
+
+        bmp.SetHBITMAP((WXHBITMAP)hbmpCheck);
+        imagelistCheckboxes.Add(bmp);
+
+        if ( !::DrawFrameControl(hdcMem, &rect,
+                                 DFC_BUTTON,
+                                 DFCS_BUTTONCHECK) )
+        {
+            wxLogLastError(wxT("DrawFrameControl(uncheck)"));
+        }
+
+        bmp.SetHBITMAP((WXHBITMAP)hbmpCheck);
+        imagelistCheckboxes.Add(bmp);
+
+        // clean up
+        ::DeleteDC(hdcMem);
+
+        // set the imagelist
+        SetStateImageList(&imagelistCheckboxes);
+    }
+#endif // 0
 
 
-    SetParent(parent);
+    SetSize(pos.x, pos.y, size.x, size.y);
 
 
-    m_windowId = (id == -1) ? NewControlId() : id;
+    return TRUE;
+}
 
 
-    if (parent) parent->AddChild(this);
+wxTreeCtrl::~wxTreeCtrl()
+{
+    DeleteTextCtrl();
 
 
-    // TODO create tree control
+    // delete user data to prevent memory leaks
+//    DeleteAllItems();
+}
 
 
-    return FALSE;
+// ----------------------------------------------------------------------------
+// accessors
+// ----------------------------------------------------------------------------
+
+// simple wrappers which add error checking in debug mode
+
+bool wxTreeCtrl::DoGetItem(wxTreeViewItem* tvItem) const
+{
+// TODO:
+/*
+    if ( !TreeView_GetItem(GetHwnd(), tvItem) )
+    {
+        wxLogLastError("TreeView_GetItem");
+
+        return FALSE;
+    }
+*/
+    return TRUE;
 }
 
 }
 
-wxTreeCtrl::~wxTreeCtrl()
+void wxTreeCtrl::DoSetItem(wxTreeViewItem* tvItem)
 {
 {
-    if (m_textCtrl)
+// TODO:
+/*
+    if ( TreeView_SetItem(GetHwnd(), tvItem) == -1 )
     {
     {
-        delete m_textCtrl;
+        wxLogLastError("TreeView_SetItem");
     }
     }
+*/
 }
 
 }
 
-// Attributes
-int wxTreeCtrl::GetCount() const
+size_t wxTreeCtrl::GetCount() const
 {
 {
-    // TODO
+//    return (size_t)TreeView_GetCount(GetHwnd());
     return 0;
 }
 
     return 0;
 }
 
-int wxTreeCtrl::GetIndent() const
+unsigned int wxTreeCtrl::GetIndent() const
 {
 {
-    // TODO
+//    return TreeView_GetIndent(GetHwnd());
     return 0;
 }
 
     return 0;
 }
 
-void wxTreeCtrl::SetIndent(int indent)
+void wxTreeCtrl::SetIndent(unsigned int indent)
 {
 {
-    // TODO
+//    TreeView_SetIndent(GetHwnd(), indent);
 }
 
 }
 
-wxImageList *wxTreeCtrl::GetImageList(int which) const
+wxImageList *wxTreeCtrl::GetImageList() const
 {
 {
-  if ( which == wxIMAGE_LIST_NORMAL )
-    {
     return m_imageListNormal;
     return m_imageListNormal;
-  }
-  else if ( which == wxIMAGE_LIST_STATE )
+}
+
+wxImageList *wxTreeCtrl::GetStateImageList() const
+{
+    return m_imageListNormal;
+}
+
+void wxTreeCtrl::SetAnyImageList(wxImageList *imageList, int which)
+{
+    // no error return
+// TODO:
+/*
+    TreeView_SetImageList(GetHwnd(),
+                          imageList ? imageList->GetHIMAGELIST() : 0,
+                          which);
+*/
+}
+
+void wxTreeCtrl::SetImageList(wxImageList *imageList)
+{
+//    SetAnyImageList(m_imageListNormal = imageList, TVSIL_NORMAL);
+}
+
+void wxTreeCtrl::SetStateImageList(wxImageList *imageList)
+{
+//    SetAnyImageList(m_imageListState = imageList, TVSIL_STATE);
+}
+
+size_t wxTreeCtrl::GetChildrenCount(const wxTreeItemId& item,
+                                    bool recursively) const
+{
+    TraverseCounter counter(this, item, recursively);
+
+    return counter.GetCount() - 1;
+}
+
+// ----------------------------------------------------------------------------
+// Item access
+// ----------------------------------------------------------------------------
+
+wxString wxTreeCtrl::GetItemText(const wxTreeItemId& item) const
+{
+    wxChar buf[512];  // the size is arbitrary...
+// TODO:
+/*
+    wxTreeViewItem tvItem(item, TVIF_TEXT);
+    tvItem.pszText = buf;
+    tvItem.cchTextMax = WXSIZEOF(buf);
+    if ( !DoGetItem(&tvItem) )
     {
     {
-    return m_imageListState;
-  }
-  return NULL;
+        // don't return some garbage which was on stack, but an empty string
+        buf[0] = wxT('\0');
+    }
+*/
+    return wxString(buf);
+}
+
+void wxTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text)
+{
+// TODO:
+/*
+    wxTreeViewItem tvItem(item, TVIF_TEXT);
+    tvItem.pszText = (wxChar *)text.c_str();  // conversion is ok
+    DoSetItem(&tvItem);
+*/
 }
 
 }
 
-void wxTreeCtrl::SetImageList(wxImageList *imageList, int which)
+int wxTreeCtrl::DoGetItemImageFromData(const wxTreeItemId& item,
+                                       wxTreeItemIcon which) const
 {
 {
-    if ( which == wxIMAGE_LIST_NORMAL )
+// TODO:
+/*
+    wxTreeViewItem tvItem(item, TVIF_PARAM);
+    if ( !DoGetItem(&tvItem) )
     {
     {
-        m_imageListNormal = imageList;
+        return -1;
     }
     }
-    else if ( which == wxIMAGE_LIST_STATE )
+    return ((wxTreeItemIndirectData *)tvItem.lParam)->GetImage(which);
+*/
+    return -1;
+}
+
+void wxTreeCtrl::DoSetItemImageFromData(const wxTreeItemId& item,
+                                        int image,
+                                        wxTreeItemIcon which) const
+{
+// TODO:
+/*
+    wxTreeViewItem tvItem(item, TVIF_PARAM);
+    if ( !DoGetItem(&tvItem) )
     {
     {
-        m_imageListState = imageList;
+        return;
     }
     }
-    // TODO
+
+    wxTreeItemIndirectData *data = ((wxTreeItemIndirectData *)tvItem.lParam);
+
+    data->SetImage(image, which);
+
+    // make sure that we have selected images as well
+    if ( which == wxTreeItemIcon_Normal &&
+         !data->HasImage(wxTreeItemIcon_Selected) )
+    {
+        data->SetImage(image, wxTreeItemIcon_Selected);
+    }
+
+    if ( which == wxTreeItemIcon_Expanded &&
+         !data->HasImage(wxTreeItemIcon_SelectedExpanded) )
+    {
+        data->SetImage(image, wxTreeItemIcon_SelectedExpanded);
+    }
+*/
 }
 
 }
 
-long wxTreeCtrl::GetNextItem(long item, int code) const
+void wxTreeCtrl::DoSetItemImages(const wxTreeItemId& item,
+                                 int image,
+                                 int imageSel)
 {
 {
-    // TODO
-    return 0;
+// TODO:
+/*
+    wxTreeViewItem tvItem(item, TVIF_IMAGE | TVIF_SELECTEDIMAGE);
+    tvItem.iSelectedImage = imageSel;
+    tvItem.iImage = image;
+    DoSetItem(&tvItem);
+*/
 }
 
 }
 
-bool wxTreeCtrl::ItemHasChildren(long item) const
+int wxTreeCtrl::GetItemImage(const wxTreeItemId& item,
+                             wxTreeItemIcon which) const
 {
 {
-    // TODO
+    if ( HasIndirectData(item) )
+    {
+        return DoGetItemImageFromData(item, which);
+    }
+
+    UINT mask;
+    switch ( which )
+    {
+        default:
+            wxFAIL_MSG( wxT("unknown tree item image type") );
+
+        case wxTreeItemIcon_Normal:
+//            mask = TVIF_IMAGE;
+            break;
+
+        case wxTreeItemIcon_Selected:
+//            mask = TVIF_SELECTEDIMAGE;
+            break;
+
+        case wxTreeItemIcon_Expanded:
+        case wxTreeItemIcon_SelectedExpanded:
+            return -1;
+    }
+
+    wxTreeViewItem tvItem(item, mask);
+    DoGetItem(&tvItem);
+
+//    return mask == TVIF_IMAGE ? tvItem.iImage : tvItem.iSelectedImage;
     return FALSE;
 }
 
     return FALSE;
 }
 
-long wxTreeCtrl::GetChild(long item) const
+void wxTreeCtrl::SetItemImage(const wxTreeItemId& item, int image,
+                              wxTreeItemIcon which)
 {
 {
-    // TODO
-    return 0;
+    int imageNormal, imageSel;
+    switch ( which )
+    {
+        default:
+            wxFAIL_MSG( wxT("unknown tree item image type") );
+
+        case wxTreeItemIcon_Normal:
+            imageNormal = image;
+            imageSel = GetItemSelectedImage(item);
+            break;
+
+        case wxTreeItemIcon_Selected:
+            imageNormal = GetItemImage(item);
+            imageSel = image;
+            break;
+
+        case wxTreeItemIcon_Expanded:
+        case wxTreeItemIcon_SelectedExpanded:
+            if ( !HasIndirectData(item) )
+            {
+                // we need to get the old images first, because after we create
+                // the wxTreeItemIndirectData GetItemXXXImage() will use it to
+                // get the images
+                imageNormal = GetItemImage(item);
+                imageSel = GetItemSelectedImage(item);
+
+                // if it doesn't have it yet, add it
+                wxTreeItemIndirectData *data = new
+                    wxTreeItemIndirectData(this, item);
+
+                // copy the data to the new location
+                data->SetImage(imageNormal, wxTreeItemIcon_Normal);
+                data->SetImage(imageSel, wxTreeItemIcon_Selected);
+            }
+
+            DoSetItemImageFromData(item, image, which);
+
+            // reset the normal/selected images because we won't use them any
+            // more - now they're stored inside the indirect data
+//            imageSel = I_IMAGECALLBACK;
+            break;
+    }
+
+    // NB: at least in version 5.00.0518.9 of comctl32.dll we need to always
+    //     change both normal and selected image - otherwise the change simply
+    //     doesn't take place!
+    DoSetItemImages(item, imageNormal, imageSel);
 }
 
 }
 
-long wxTreeCtrl::GetParent(long item) const
+wxTreeItemData *wxTreeCtrl::GetItemData(const wxTreeItemId& item) const
 {
 {
-    // TODO
+// TODO:
+/*
+    wxTreeViewItem tvItem(item, TVIF_PARAM);
+    if ( !DoGetItem(&tvItem) )
+    {
+        return NULL;
+    }
+
+    if ( HasIndirectData(item) )
+    {
+        return ((wxTreeItemIndirectData *)tvItem.lParam)->GetData();
+    }
+    else
+    {
+        return (wxTreeItemData *)tvItem.lParam;
+    }
+*/
     return 0;
 }
 
     return 0;
 }
 
-long wxTreeCtrl::GetFirstVisibleItem() const
+void wxTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data)
 {
 {
-    // TODO
-    return 0;
+// TODO:
+/*
+    wxTreeViewItem tvItem(item, TVIF_PARAM);
+
+    if ( HasIndirectData(item) )
+    {
+        if ( DoGetItem(&tvItem) )
+        {
+            ((wxTreeItemIndirectData *)tvItem.lParam)->SetData(data);
+        }
+        else
+        {
+            wxFAIL_MSG( wxT("failed to change tree items data") );
+        }
+    }
+    else
+    {
+        tvItem.lParam = (MPARAM)data;
+        DoSetItem(&tvItem);
+    }
+*/
 }
 
 }
 
-long wxTreeCtrl::GetNextVisibleItem(long item) const
+void wxTreeCtrl::SetIndirectItemData(const wxTreeItemId& item,
+                                     wxTreeItemIndirectData *data)
 {
 {
-    // TODO
-    return 0;
+    // this should never happen because it's unnecessary and will probably lead
+    // to crash too because the code elsewhere supposes that the pointer the
+    // wxTreeItemIndirectData has is a real wxItemData and not
+    // wxTreeItemIndirectData as well
+    wxASSERT_MSG( !HasIndirectData(item), wxT("setting indirect data twice?") );
+
+    SetItemData(item, (wxTreeItemData *)data);
+
+    m_itemsWithIndirectData.Add(item);
 }
 
 }
 
-long wxTreeCtrl::GetSelection() const
+bool wxTreeCtrl::HasIndirectData(const wxTreeItemId& item) const
 {
 {
-    // TODO
-    return 0;
+    return m_itemsWithIndirectData.Index(item) != wxNOT_FOUND;
 }
 
 }
 
-long wxTreeCtrl::GetRootItem() const
+void wxTreeCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
 {
 {
-    // TODO
-    return 0;
+// TODO:
+/*
+    wxTreeViewItem tvItem(item, TVIF_CHILDREN);
+    tvItem.cChildren = (int)has;
+    DoSetItem(&tvItem);
+*/
+}
+
+void wxTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
+{
+// TODO:
+/*
+    wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_BOLD);
+    tvItem.state = bold ? TVIS_BOLD : 0;
+    DoSetItem(&tvItem);
+*/
+}
+
+void wxTreeCtrl::SetItemDropHighlight(const wxTreeItemId& item, bool highlight)
+{
+// TODO:
+/*
+    wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_DROPHILITED);
+    tvItem.state = highlight ? TVIS_DROPHILITED : 0;
+    DoSetItem(&tvItem);
+*/
 }
 
 }
 
-bool wxTreeCtrl::GetItem(wxTreeItem& info) const
+// ----------------------------------------------------------------------------
+// Item status
+// ----------------------------------------------------------------------------
+
+bool wxTreeCtrl::IsVisible(const wxTreeItemId& item) const
 {
 {
-    // TODO
+    // Bug in Gnu-Win32 headers, so don't use the macro TreeView_GetItemRect
+// TODO:
+/*
+    RECT rect;
+    return SendMessage(GetHwnd(), TVM_GETITEMRECT, FALSE, (LPARAM)&rect) != 0;
+*/
     return FALSE;
 }
 
     return FALSE;
 }
 
-bool wxTreeCtrl::SetItem(wxTreeItem& info)
+bool wxTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const
 {
 {
-    // TODO
+// TODO:
+/*
+    wxTreeViewItem tvItem(item, TVIF_CHILDREN);
+    DoGetItem(&tvItem);
+
+    return tvItem.cChildren != 0;
+*/
     return FALSE;
 }
 
     return FALSE;
 }
 
-int wxTreeCtrl::GetItemState(long item, long stateMask) const
+bool wxTreeCtrl::IsExpanded(const wxTreeItemId& item) const
 {
 {
-    wxTreeItem info;
+    // probably not a good idea to put it here
+    //wxASSERT( ItemHasChildren(item) );
 
 
-    info.m_mask = wxTREE_MASK_STATE ;
-    info.m_stateMask = stateMask;
-    info.m_itemId = item;
+// TODO:
+/*
+    wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_EXPANDED);
+    DoGetItem(&tvItem);
 
 
-    if (!GetItem(info))
-        return 0;
+    return (tvItem.state & TVIS_EXPANDED) != 0;
+*/
+    return FALSE;
+}
 
 
-    return info.m_state;
+bool wxTreeCtrl::IsSelected(const wxTreeItemId& item) const
+{
+// TODO:
+/*
+    wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_SELECTED);
+    DoGetItem(&tvItem);
+
+    return (tvItem.state & TVIS_SELECTED) != 0;
+*/
+    return FALSE;
 }
 
 }
 
-bool wxTreeCtrl::SetItemState(long item, long state, long stateMask)
+bool wxTreeCtrl::IsBold(const wxTreeItemId& item) const
 {
 {
-    wxTreeItem info;
+// TODO:
+/*
+    wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_BOLD);
+    DoGetItem(&tvItem);
 
 
-    info.m_mask = wxTREE_MASK_STATE ;
-    info.m_state = state;
-    info.m_stateMask = stateMask;
-    info.m_itemId = item;
+    return (tvItem.state & TVIS_BOLD) != 0;
+*/
+    return FALSE;
+}
 
 
-    return SetItem(info);
+// ----------------------------------------------------------------------------
+// navigation
+// ----------------------------------------------------------------------------
+
+wxTreeItemId wxTreeCtrl::GetRootItem() const
+{
+//    return wxTreeItemId((WXHTREEITEM) TreeView_GetRoot(GetHwnd()));
+    return 0;
 }
 
 }
 
-bool wxTreeCtrl::SetItemImage(long item, int image, int selImage)
+wxTreeItemId wxTreeCtrl::GetSelection() const
 {
 {
-    wxTreeItem info;
+    wxCHECK_MSG( !(m_windowStyle & wxTR_MULTIPLE), (WXHTREEITEM)0,
+                 wxT("this only works with single selection controls") );
 
 
-    info.m_mask = wxTREE_MASK_IMAGE ;
-    info.m_image = image;
-    if ( selImage > -1)
-    {
-        info.m_selectedImage = selImage;
-        info.m_mask |= wxTREE_MASK_SELECTED_IMAGE;
-    }
-    info.m_itemId = item;
+//    return wxTreeItemId((WXHTREEITEM) TreeView_GetSelection(GetHwnd()));
+    return 0;
+}
 
 
-    return SetItem(info);
+wxTreeItemId wxTreeCtrl::GetParent(const wxTreeItemId& item) const
+{
+//    return wxTreeItemId((WXHTREEITEM) TreeView_GetParent(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item));
+    return 0;
 }
 
 }
 
-wxString wxTreeCtrl::GetItemText(long item) const
+wxTreeItemId wxTreeCtrl::GetFirstChild(const wxTreeItemId& item,
+                                       long& _cookie) const
 {
 {
-    wxTreeItem info;
+// TODO:
+/*
+    // remember the last child returned in 'cookie'
+    _cookie = (long)TreeView_GetChild(GetHwnd(), (HTREEITEM) (WXHTREEITEM)item);
+
+    return wxTreeItemId((WXHTREEITEM)_cookie);
+*/
+    return 0;
+}
 
 
-    info.m_mask = wxTREE_MASK_TEXT ;
-    info.m_itemId = item;
+wxTreeItemId wxTreeCtrl::GetNextChild(const wxTreeItemId& WXUNUSED(item),
+                                      long& _cookie) const
+{
+    wxTreeItemId l = 0; //wxTreeItemId((WXHTREEITEM)TreeView_GetNextSibling(GetHwnd(),
+//                                   (HTREEITEM)(WXHTREEITEM)_cookie));
+    _cookie = (long)l;
 
 
-    if (!GetItem(info))
-        return wxString("");
-    return info.m_text;
+    return l;
 }
 
 }
 
-void wxTreeCtrl::SetItemText(long item, const wxString& str)
+wxTreeItemId wxTreeCtrl::GetLastChild(const wxTreeItemId& item) const
 {
 {
-    wxTreeItem info;
+    // can this be done more efficiently?
+    long cookie;
 
 
-    info.m_mask = wxTREE_MASK_TEXT ;
-    info.m_itemId = item;
-    info.m_text = str;
+    wxTreeItemId childLast,
+    child = GetFirstChild(item, cookie);
+    while ( child.IsOk() )
+    {
+        childLast = child;
+        child = GetNextChild(item, cookie);
+    }
 
 
-    SetItem(info);
+    return childLast;
 }
 
 }
 
-long wxTreeCtrl::GetItemData(long item) const
+wxTreeItemId wxTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
 {
 {
-    wxTreeItem info;
+//    return wxTreeItemId((WXHTREEITEM) TreeView_GetNextSibling(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item));
+    return 0;
+}
 
 
-    info.m_mask = wxTREE_MASK_DATA ;
-    info.m_itemId = item;
+wxTreeItemId wxTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const
+{
+//    return wxTreeItemId((WXHTREEITEM) TreeView_GetPrevSibling(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item));
+    return 0;
+}
 
 
-    if (!GetItem(info))
-        return 0;
-    return info.m_data;
+wxTreeItemId wxTreeCtrl::GetFirstVisibleItem() const
+{
+//     return wxTreeItemId((WXHTREEITEM) TreeView_GetFirstVisible(GetHwnd()));
+    return 0;
 }
 
 }
 
-bool wxTreeCtrl::SetItemData(long item, long data)
+wxTreeItemId wxTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
 {
 {
-    wxTreeItem info;
+    wxASSERT_MSG( IsVisible(item), wxT("The item you call GetNextVisible() "
+                                      "for must be visible itself!"));
+
+//    return wxTreeItemId((WXHTREEITEM) TreeView_GetNextVisible(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item));
+    return 0;
+}
 
 
-    info.m_mask = wxTREE_MASK_DATA ;
-    info.m_itemId = item;
-    info.m_data = data;
+wxTreeItemId wxTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
+{
+    wxASSERT_MSG( IsVisible(item), wxT("The item you call GetPrevVisible() "
+                                      "for must be visible itself!"));
 
 
-    return SetItem(info);
+//    return wxTreeItemId((WXHTREEITEM) TreeView_GetPrevVisible(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item));
+     return 0;
 }
 
 }
 
-bool wxTreeCtrl::GetItemRect(long item, wxRect& rect, bool textOnly) const
+// ----------------------------------------------------------------------------
+// multiple selections emulation
+// ----------------------------------------------------------------------------
+
+bool wxTreeCtrl::IsItemChecked(const wxTreeItemId& item) const
 {
 {
-    // TODO
+    // receive the desired information.
+// TODO:
+/*
+    wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_STATEIMAGEMASK);
+    DoGetItem(&tvItem);
+
+    // state image indices are 1 based
+    return ((tvItem.state >> 12) - 1) == 1;
+*/
     return FALSE;
 }
 
     return FALSE;
 }
 
-wxTextCtrl* wxTreeCtrl::GetEditControl() const
+void wxTreeCtrl::SetItemCheck(const wxTreeItemId& item, bool check)
 {
 {
-    return m_textCtrl;
+    // receive the desired information.
+// TODO:
+/*
+    wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_STATEIMAGEMASK);
+
+    // state images are one-based
+    tvItem.state = (check ? 2 : 1) << 12;
+
+    DoSetItem(&tvItem);
+*/
 }
 
 }
 
-// Operations
-bool wxTreeCtrl::DeleteItem(long item)
+size_t wxTreeCtrl::GetSelections(wxArrayTreeItemIds& selections) const
 {
 {
-    // TODO
-    return FALSE;
+    TraverseSelections selector(this, selections);
+
+    return selections.GetCount();
 }
 
 }
 
-bool wxTreeCtrl::ExpandItem(long item, int action)
+// ----------------------------------------------------------------------------
+// Usual operations
+// ----------------------------------------------------------------------------
+
+wxTreeItemId wxTreeCtrl::DoInsertItem(const wxTreeItemId& parent,
+                                      wxTreeItemId hInsertAfter,
+                                      const wxString& text,
+                                      int image, int selectedImage,
+                                      wxTreeItemData *data)
 {
 {
-    // TODO
-  switch ( action )
-  {
-    case wxTREE_EXPAND_EXPAND:
-      break;
+// TODO:
+/*
+    TV_INSERTSTRUCT tvIns;
+    tvIns.hParent = (HTREEITEM) (WXHTREEITEM)parent;
+    tvIns.hInsertAfter = (HTREEITEM) (WXHTREEITEM) hInsertAfter;
+
+    // this is how we insert the item as the first child: supply a NULL
+    // hInsertAfter
+    if ( !tvIns.hInsertAfter )
+    {
+        tvIns.hInsertAfter = TVI_FIRST;
+    }
 
 
-    case wxTREE_EXPAND_COLLAPSE:
-      break;
+    UINT mask = 0;
+    if ( !text.IsEmpty() )
+    {
+        mask |= TVIF_TEXT;
+        tvIns.item.pszText = (wxChar *)text.c_str();  // cast is ok
+    }
 
 
-    case wxTREE_EXPAND_COLLAPSE_RESET:
-      break;
+    if ( image != -1 )
+    {
+        mask |= TVIF_IMAGE;
+        tvIns.item.iImage = image;
+
+        if ( selectedImage == -1 )
+        {
+            // take the same image for selected icon if not specified
+            selectedImage = image;
+        }
+    }
 
 
-    case wxTREE_EXPAND_TOGGLE:
-      break;
+    if ( selectedImage != -1 )
+    {
+        mask |= TVIF_SELECTEDIMAGE;
+        tvIns.item.iSelectedImage = selectedImage;
+    }
 
 
-    default:
-      wxFAIL_MSG("unknown action in wxTreeCtrl::ExpandItem");
-  }
+    if ( data != NULL )
+    {
+        mask |= TVIF_PARAM;
+        tvIns.item.lParam = (LPARAM)data;
+    }
 
 
-  bool bOk = FALSE; // TODO expand item
+    tvIns.item.mask = mask;
 
 
-  // May not send messages, so emulate them
-  if ( bOk ) {
-    wxTreeEvent event(wxEVT_NULL, m_windowId);
-    event.m_item.m_itemId  = item;
-    event.m_item.m_mask      =
-    event.m_item.m_stateMask = 0xffff; // get all
-    GetItem(event.m_item);
+    HTREEITEM id = (HTREEITEM) TreeView_InsertItem(GetHwnd(), &tvIns);
+    if ( id == 0 )
+    {
+        wxLogLastError("TreeView_InsertItem");
+    }
+
+    if ( data != NULL )
+    {
+        // associate the application tree item with Win32 tree item handle
+        data->SetId((WXHTREEITEM)id);
+    }
 
 
-    bool bIsExpanded = (event.m_item.m_state & wxTREE_STATE_EXPANDED) != 0;
+    return wxTreeItemId((WXHTREEITEM)id);
+*/
+    return 0;
+}
 
 
-    event.m_code = action;
-    event.SetEventObject(this);
+// for compatibility only
+wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parent,
+                                    const wxString& text,
+                                    int image, int selImage,
+                                    long insertAfter)
+{
+    return DoInsertItem(parent, (WXHTREEITEM)insertAfter, text,
+                        image, selImage, NULL);
+}
 
 
-    // @@@ return values of {EXPAND|COLLAPS}ING event handler is discarded
-    event.SetEventType(bIsExpanded ? wxEVT_COMMAND_TREE_ITEM_EXPANDING
-                                   : wxEVT_COMMAND_TREE_ITEM_COLLAPSING);
-    GetEventHandler()->ProcessEvent(event);
+wxTreeItemId wxTreeCtrl::AddRoot(const wxString& text,
+                                 int image, int selectedImage,
+                                 wxTreeItemData *data)
+{
+    return DoInsertItem(wxTreeItemId((WXHTREEITEM) 0), (WXHTREEITEM) 0,
+                        text, image, selectedImage, data);
+}
 
 
-    event.SetEventType(bIsExpanded ? wxEVT_COMMAND_TREE_ITEM_EXPANDED
-                                   : wxEVT_COMMAND_TREE_ITEM_COLLAPSED);
-    GetEventHandler()->ProcessEvent(event);
-  }
+wxTreeItemId wxTreeCtrl::PrependItem(const wxTreeItemId& parent,
+                                     const wxString& text,
+                                     int image, int selectedImage,
+                                     wxTreeItemData *data)
+{
+// TODO:
+/*
+    return DoInsertItem(parent, (WXHTREEITEM) TVI_FIRST,
+                        text, image, selectedImage, data);
+*/
+    return 0;
+}
 
 
-  return bOk;
+wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parent,
+                                    const wxTreeItemId& idPrevious,
+                                    const wxString& text,
+                                    int image, int selectedImage,
+                                    wxTreeItemData *data)
+{
+    return DoInsertItem(parent, idPrevious, text, image, selectedImage, data);
 }
 
 }
 
-long wxTreeCtrl::InsertItem(long parent, wxTreeItem& info, long insertAfter)
+wxTreeItemId wxTreeCtrl::AppendItem(const wxTreeItemId& parent,
+                                    const wxString& text,
+                                    int image, int selectedImage,
+                                    wxTreeItemData *data)
 {
 {
-    // TODO
+// TODO:
+/*
+    return DoInsertItem(parent, (WXHTREEITEM) TVI_LAST,
+                        text, image, selectedImage, data);
+*/
     return 0;
 }
 
     return 0;
 }
 
-long wxTreeCtrl::InsertItem(long parent, const wxString& label, int image, int selImage,
-  long insertAfter)
+void wxTreeCtrl::Delete(const wxTreeItemId& item)
 {
 {
-    wxTreeItem info;
-    info.m_text = label;
-    info.m_mask = wxTREE_MASK_TEXT;
-    if ( image > -1 )
+// TODO:
+/*
+    if ( !TreeView_DeleteItem(GetHwnd(), (HTREEITEM)(WXHTREEITEM)item) )
     {
     {
-        info.m_mask |= wxTREE_MASK_IMAGE | wxTREE_MASK_SELECTED_IMAGE;
-        info.m_image = image;
-        if ( selImage == -1 )
-            info.m_selectedImage = image;
-        else
-            info.m_selectedImage = selImage;
+        wxLogLastError("TreeView_DeleteItem");
+    }
+*/
+}
+
+// delete all children (but don't delete the item itself)
+void wxTreeCtrl::DeleteChildren(const wxTreeItemId& item)
+{
+    long cookie;
+
+    wxArrayLong children;
+    wxTreeItemId child = GetFirstChild(item, cookie);
+    while ( child.IsOk() )
+    {
+        children.Add((long)(WXHTREEITEM)child);
+
+        child = GetNextChild(item, cookie);
     }
 
     }
 
-    return InsertItem(parent, info, insertAfter);
+    size_t nCount = children.Count();
+// TODO:
+/*
+    for ( size_t n = 0; n < nCount; n++ )
+    {
+        if ( !TreeView_DeleteItem(GetHwnd(), (HTREEITEM)children[n]) )
+        {
+            wxLogLastError("TreeView_DeleteItem");
+        }
+    }
+*/
 }
 
 }
 
-bool wxTreeCtrl::SelectItem(long item)
+void wxTreeCtrl::DeleteAllItems()
 {
 {
-    // TODO
-    return FALSE;
+// TODO:
+/*
+    if ( !TreeView_DeleteAllItems(GetHwnd()) )
+    {
+        wxLogLastError("TreeView_DeleteAllItems");
+    }
+*/
 }
 
 }
 
-bool wxTreeCtrl::ScrollTo(long item)
+void wxTreeCtrl::DoExpand(const wxTreeItemId& item, int flag)
 {
 {
-    // TODO
-    return FALSE;
+// TODO:
+/*
+    wxASSERT_MSG( flag == TVE_COLLAPSE ||
+                  flag == (TVE_COLLAPSE | TVE_COLLAPSERESET) ||
+                  flag == TVE_EXPAND   ||
+                  flag == TVE_TOGGLE,
+                  wxT("Unknown flag in wxTreeCtrl::DoExpand") );
+
+    // 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
+    // compatible behaviour and also in order to not have surprises with the
+    // future versions, don't rely on this and still do everything ourselves.
+    // To avoid that the messages be sent twice when the item is expanded for
+    // the first time we must clear TVIS_EXPANDEDONCE style manually.
+
+    wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_EXPANDEDONCE);
+    tvItem.state = 0;
+    DoSetItem(&tvItem);
+
+    if ( TreeView_Expand(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item, flag) != 0 )
+    {
+        wxTreeEvent event(wxEVT_NULL, m_windowId);
+        event.m_item = item;
+
+        bool isExpanded = IsExpanded(item);
+
+        event.SetEventObject(this);
+
+        // FIXME return value of {EXPAND|COLLAPS}ING event handler is discarded
+        event.SetEventType(g_events[isExpanded][TRUE]);
+        GetEventHandler()->ProcessEvent(event);
+
+        event.SetEventType(g_events[isExpanded][FALSE]);
+        GetEventHandler()->ProcessEvent(event);
+    }
+    //else: change didn't took place, so do nothing at all
+*/
 }
 
 }
 
-bool wxTreeCtrl::DeleteAllItems()
+void wxTreeCtrl::Expand(const wxTreeItemId& item)
 {
 {
-    // TODO
-    return FALSE;
+//    DoExpand(item, TVE_EXPAND);
 }
 
 }
 
-wxTextCtrl* wxTreeCtrl::EditLabel(long item, wxClassInfo* textControlClass)
+void wxTreeCtrl::Collapse(const wxTreeItemId& item)
 {
 {
-    // TODO
-    return NULL;
+//    DoExpand(item, TVE_COLLAPSE);
+}
+
+void wxTreeCtrl::CollapseAndReset(const wxTreeItemId& item)
+{
+//    DoExpand(item, TVE_COLLAPSE | TVE_COLLAPSERESET);
+}
+
+void wxTreeCtrl::Toggle(const wxTreeItemId& item)
+{
+//    DoExpand(item, TVE_TOGGLE);
+}
+
+void wxTreeCtrl::ExpandItem(const wxTreeItemId& item, int action)
+{
+//    DoExpand(item, action);
+}
+
+void wxTreeCtrl::Unselect()
+{
+    wxASSERT_MSG( !(m_windowStyle & wxTR_MULTIPLE), wxT("doesn't make sense") );
+
+    // just remove the selection
+//    SelectItem(wxTreeItemId((WXHTREEITEM) 0));
+}
+
+void wxTreeCtrl::UnselectAll()
+{
+    if ( m_windowStyle & wxTR_MULTIPLE )
+    {
+        wxArrayTreeItemIds selections;
+        size_t count = GetSelections(selections);
+        for ( size_t n = 0; n < count; n++ )
+        {
+            SetItemCheck(selections[n], FALSE);
+        }
+    }
+    else
+    {
+        // just remove the selection
+        Unselect();
+    }
+}
+
+void wxTreeCtrl::SelectItem(const wxTreeItemId& item)
+{
+    if ( m_windowStyle & wxTR_MULTIPLE )
+    {
+        // selecting the item means checking it
+        SetItemCheck(item);
+    }
+    else
+    {
+        // inspite of the docs (MSDN Jan 99 edition), we don't seem to receive
+        // the notification from the control (i.e. TVN_SELCHANG{ED|ING}), so
+        // send them ourselves
+
+        wxTreeEvent event(wxEVT_NULL, m_windowId);
+        event.m_item = item;
+        event.SetEventObject(this);
+
+        event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGING);
+// TODO:
+/*
+        if ( !GetEventHandler()->ProcessEvent(event) || event.IsAllowed() )
+        {
+            if ( !TreeView_SelectItem(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item) )
+            {
+                wxLogLastError("TreeView_SelectItem");
+            }
+            else
+            {
+                event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
+                (void)GetEventHandler()->ProcessEvent(event);
+            }
+        }
+        //else: program vetoed the change
+*/
+    }
+}
+
+void wxTreeCtrl::EnsureVisible(const wxTreeItemId& item)
+{
+    // no error return
+//    TreeView_EnsureVisible(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item);
+}
+
+void wxTreeCtrl::ScrollTo(const wxTreeItemId& item)
+{
+// TODO:
+/*
+    if ( !TreeView_SelectSetFirstVisible(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item) )
+    {
+        wxLogLastError("TreeView_SelectSetFirstVisible");
+    }
+*/
+}
+
+wxTextCtrl* wxTreeCtrl::GetEditControl() const
+{
+    return m_textCtrl;
+}
+
+void wxTreeCtrl::DeleteTextCtrl()
+{
+    if ( m_textCtrl )
+    {
+        m_textCtrl->UnsubclassWin();
+        m_textCtrl->SetHWND(0);
+        delete m_textCtrl;
+        m_textCtrl = NULL;
+    }
+}
+
+wxTextCtrl* wxTreeCtrl::EditLabel(const wxTreeItemId& item,
+                                  wxClassInfo* textControlClass)
+{
+    wxASSERT( textControlClass->IsKindOf(CLASSINFO(wxTextCtrl)) );
+
+// TODO:
+/*
+    HWND hWnd = (HWND) TreeView_EditLabel(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item);
+
+    // this is not an error - the TVN_BEGINLABELEDIT handler might have
+    // returned FALSE
+    if ( !hWnd )
+    {
+        return NULL;
+    }
+
+    DeleteTextCtrl();
+
+    m_textCtrl = (wxTextCtrl *)textControlClass->CreateObject();
+    m_textCtrl->SetHWND((WXHWND)hWnd);
+    m_textCtrl->SubclassWin((WXHWND)hWnd);
+*/
+    return m_textCtrl;
 }
 
 // End label editing, optionally cancelling the edit
 }
 
 // End label editing, optionally cancelling the edit
-bool wxTreeCtrl::EndEditLabel(bool cancel)
+void wxTreeCtrl::EndEditLabel(const wxTreeItemId& item, bool discardChanges)
 {
 {
-    // TODO
-    return FALSE;
+//    TreeView_EndEditLabelNow(GetHwnd(), discardChanges);
+
+    DeleteTextCtrl();
 }
 
 }
 
-long wxTreeCtrl::HitTest(const wxPoint& point, int& flags)
+wxTreeItemId wxTreeCtrl::HitTest(const wxPoint& point, int& flags)
 {
 {
-    // TODO
+// TODO:
+/*
+    TV_HITTESTINFO hitTestInfo;
+    hitTestInfo.pt.x = (int)point.x;
+    hitTestInfo.pt.y = (int)point.y;
+
+    TreeView_HitTest(GetHwnd(), &hitTestInfo);
+
+    flags = 0;
+
+    // avoid repetition
+    #define TRANSLATE_FLAG(flag) if ( hitTestInfo.flags & TVHT_##flag ) \
+                                    flags |= wxTREE_HITTEST_##flag
+
+    TRANSLATE_FLAG(ABOVE);
+    TRANSLATE_FLAG(BELOW);
+    TRANSLATE_FLAG(NOWHERE);
+    TRANSLATE_FLAG(ONITEMBUTTON);
+    TRANSLATE_FLAG(ONITEMICON);
+    TRANSLATE_FLAG(ONITEMINDENT);
+    TRANSLATE_FLAG(ONITEMLABEL);
+    TRANSLATE_FLAG(ONITEMRIGHT);
+    TRANSLATE_FLAG(ONITEMSTATEICON);
+    TRANSLATE_FLAG(TOLEFT);
+    TRANSLATE_FLAG(TORIGHT);
+
+    #undef TRANSLATE_FLAG
+
+    return wxTreeItemId((WXHTREEITEM) hitTestInfo.hItem);
+*/
     return 0;
 }
 
     return 0;
 }
 
-bool wxTreeCtrl::SortChildren(long item)
+bool wxTreeCtrl::GetBoundingRect(const wxTreeItemId& item,
+                                 wxRect& rect,
+                                 bool textOnly) const
 {
 {
-    // TODO
+// TODO:
+/*
+    RECT rc;
+    if ( TreeView_GetItemRect(GetHwnd(), (HTREEITEM)(WXHTREEITEM)item,
+                              &rc, textOnly) )
+    {
+        rect = wxRect(wxPoint(rc.left, rc.top), wxPoint(rc.right, rc.bottom));
+
+        return TRUE;
+    }
+    else
+    {
+        // couldn't retrieve rect: for example, item isn't visible
+        return FALSE;
+    }
+*/
     return FALSE;
 }
 
     return FALSE;
 }
 
-bool wxTreeCtrl::EnsureVisible(long item)
+// ----------------------------------------------------------------------------
+// sorting stuff
+// ----------------------------------------------------------------------------
+
+static int TreeView_CompareCallback(wxTreeItemData *pItem1,
+                                    wxTreeItemData *pItem2,
+                                    wxTreeCtrl *tree)
+{
+    wxCHECK_MSG( pItem1 && pItem2, 0,
+                 wxT("sorting tree without data doesn't make sense") );
+
+    return tree->OnCompareItems(pItem1->GetId(), pItem2->GetId());
+}
+
+int wxTreeCtrl::OnCompareItems(const wxTreeItemId& item1,
+                               const wxTreeItemId& item2)
+{
+    return wxStrcmp(GetItemText(item1), GetItemText(item2));
+}
+
+void wxTreeCtrl::SortChildren(const wxTreeItemId& item)
+{
+    // rely on the fact that TreeView_SortChildren does the same thing as our
+    // default behaviour, i.e. sorts items alphabetically and so call it
+    // directly if we're not in derived class (much more efficient!)
+// TODO:
+/*
+    if ( GetClassInfo() == CLASSINFO(wxTreeCtrl) )
+    {
+        TreeView_SortChildren(GetHwnd(), (HTREEITEM)(WXHTREEITEM)item, 0);
+    }
+    else
+    {
+        TV_SORTCB tvSort;
+        tvSort.hParent = (HTREEITEM)(WXHTREEITEM)item;
+        tvSort.lpfnCompare = (PFNTVCOMPARE)TreeView_CompareCallback;
+        tvSort.lParam = (LPARAM)this;
+        TreeView_SortChildrenCB(GetHwnd(), &tvSort, 0);
+    }
+*/
+}
+
+// ----------------------------------------------------------------------------
+// implementation
+// ----------------------------------------------------------------------------
+
+bool wxTreeCtrl::OS2Command(WXUINT cmd, WXWORD id)
 {
 {
-    // TODO
+// TODO:
+/*
+    if ( cmd == EN_UPDATE )
+    {
+        wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, id);
+        event.SetEventObject( this );
+        ProcessCommand(event);
+    }
+    else if ( cmd == EN_KILLFOCUS )
+    {
+        wxCommandEvent event(wxEVT_KILL_FOCUS, id);
+        event.SetEventObject( this );
+        ProcessCommand(event);
+    }
+    else
+    {
+        // nothing done
+        return FALSE;
+    }
+
+    // command processed
+    return TRUE;
+*/
     return FALSE;
 }
 
     return FALSE;
 }
 
-// Tree item structure
-wxTreeItem::wxTreeItem()
+// process WM_NOTIFY Windows message
+bool wxTreeCtrl::OS2OnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
 {
 {
-    m_mask = 0;
-    m_itemId = 0;
-    m_state = 0;
-    m_stateMask = 0;
-    m_image = -1;
-    m_selectedImage = -1;
-    m_children = 0;
-    m_data = 0;
+// TODO:
+/*
+    wxTreeEvent event(wxEVT_NULL, m_windowId);
+    wxEventType eventType = wxEVT_NULL;
+    NMHDR *hdr = (NMHDR *)lParam;
+
+    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_BEGINRDRAG:
+            {
+                if ( eventType == wxEVT_NULL )
+                    eventType = wxEVT_COMMAND_TREE_BEGIN_RDRAG;
+                //else: left drag, already set above
+
+                NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
+
+                event.m_item = (WXHTREEITEM) tv->itemNew.hItem;
+                event.m_pointDrag = wxPoint(tv->ptDrag.x, tv->ptDrag.y);
+                break;
+            }
+
+        case TVN_BEGINLABELEDIT:
+            {
+                eventType = wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT;
+                TV_DISPINFO *info = (TV_DISPINFO *)lParam;
+
+                event.m_item = (WXHTREEITEM) info->item.hItem;
+                event.m_label = info->item.pszText;
+                break;
+            }
+
+        case TVN_DELETEITEM:
+            {
+                eventType = wxEVT_COMMAND_TREE_DELETE_ITEM;
+                NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
+
+                event.m_item = (WXHTREEITEM) tv->itemOld.hItem;
+                break;
+            }
+
+        case TVN_ENDLABELEDIT:
+            {
+                eventType = wxEVT_COMMAND_TREE_END_LABEL_EDIT;
+                TV_DISPINFO *info = (TV_DISPINFO *)lParam;
+
+                event.m_item = (WXHTREEITEM)info->item.hItem;
+                event.m_label = info->item.pszText;
+                break;
+            }
+
+        case TVN_GETDISPINFO:
+            eventType = wxEVT_COMMAND_TREE_GET_INFO;
+            // fall through
+
+        case TVN_SETDISPINFO:
+            {
+                if ( eventType == wxEVT_NULL )
+                    eventType = wxEVT_COMMAND_TREE_SET_INFO;
+                //else: get, already set above
+
+                TV_DISPINFO *info = (TV_DISPINFO *)lParam;
+
+                event.m_item = (WXHTREEITEM) info->item.hItem;
+                break;
+            }
+
+        case TVN_ITEMEXPANDING:
+            event.m_code = FALSE;
+            // fall through
+
+        case TVN_ITEMEXPANDED:
+            {
+                NM_TREEVIEW* tv = (NM_TREEVIEW*)lParam;
+
+                bool expand = FALSE;
+                switch ( tv->action )
+                {
+                    case TVE_EXPAND:
+                        expand = TRUE;
+                        break;
+
+                    case TVE_COLLAPSE:
+                        expand = FALSE;
+                        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];
+
+                event.m_item = (WXHTREEITEM) tv->itemNew.hItem;
+                break;
+            }
+
+        case TVN_KEYDOWN:
+            {
+                eventType = wxEVT_COMMAND_TREE_KEY_DOWN;
+                TV_KEYDOWN *info = (TV_KEYDOWN *)lParam;
+
+                event.m_code = wxCharCodeMSWToWX(info->wVKey);
+
+                // a separate event for this case
+                if ( info->wVKey == VK_SPACE || info->wVKey == VK_RETURN )
+                {
+                    wxTreeEvent event2(wxEVT_COMMAND_TREE_ITEM_ACTIVATED,
+                                       m_windowId);
+                    event2.SetEventObject(this);
+
+                    GetEventHandler()->ProcessEvent(event2);
+                }
+                break;
+            }
+
+        case TVN_SELCHANGED:
+            eventType = wxEVT_COMMAND_TREE_SEL_CHANGED;
+            // fall through
+
+        case TVN_SELCHANGING:
+            {
+                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;
+                break;
+            }
+
+        default:
+            return wxControl::MSWOnNotify(idCtrl, lParam, result);
+    }
+
+    event.SetEventObject(this);
+    event.SetEventType(eventType);
+
+    bool processed = GetEventHandler()->ProcessEvent(event);
+
+    // post processing
+    switch ( hdr->code )
+    {
+        case TVN_DELETEITEM:
+            {
+                // NB: we might process this message using wxWindows event
+                //     tables, but due to overhead of wxWin event system we
+                //     prefer to do it here ourself (otherwise deleting a tree
+                //     with many items is just too slow)
+                NM_TREEVIEW* tv = (NM_TREEVIEW *)lParam;
+
+                wxTreeItemId item = event.m_item;
+                if ( HasIndirectData(item) )
+                {
+                    wxTreeItemIndirectData *data = (wxTreeItemIndirectData *)
+                                                        tv->itemOld.lParam;
+                    delete data; // can't be NULL here
+
+                    m_itemsWithIndirectData.Remove(item);
+                }
+                else
+                {
+                    wxTreeItemData *data = (wxTreeItemData *)tv->itemOld.lParam;
+                    delete data; // may be NULL, ok
+                }
+
+                processed = TRUE; // Make sure we don't get called twice
+            }
+            break;
+
+        case TVN_BEGINLABELEDIT:
+            // return TRUE to cancel label editing
+            *result = !event.IsAllowed();
+            break;
+
+        case TVN_ENDLABELEDIT:
+            // return TRUE to set the label to the new string
+            *result = event.IsAllowed();
+
+            // ensure that we don't have the text ctrl which is going to be
+            // deleted any more
+            DeleteTextCtrl();
+            break;
+
+        case TVN_SELCHANGING:
+        case TVN_ITEMEXPANDING:
+            // return TRUE to prevent the action from happening
+            *result = !event.IsAllowed();
+            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
+            if ( 1 // !processed && )
+            {
+                wxTreeItemId item = event.m_item;
+                TV_DISPINFO *info = (TV_DISPINFO *)lParam;
+                if ( info->item.mask & TVIF_IMAGE )
+                {
+                    info->item.iImage =
+                        DoGetItemImageFromData
+                        (
+                         item,
+                         IsExpanded(item) ? wxTreeItemIcon_Expanded
+                                          : wxTreeItemIcon_Normal
+                        );
+                }
+                if ( info->item.mask & TVIF_SELECTEDIMAGE )
+                {
+                    info->item.iSelectedImage =
+                        DoGetItemImageFromData
+                        (
+                         item,
+                         IsExpanded(item) ? wxTreeItemIcon_SelectedExpanded
+                                          : wxTreeItemIcon_Selected
+                        );
+                }
+            }
+            break;
+
+        //default:
+            // for the other messages the return value is ignored and there is
+            // nothing special to do
+    }
+
+    return processed;
+*/
+    return FALSE;
 }
 
 }
 
+// ----------------------------------------------------------------------------
 // Tree event
 // Tree event
-IMPLEMENT_DYNAMIC_CLASS(wxTreeEvent, wxCommandEvent)
+// ----------------------------------------------------------------------------
+
+IMPLEMENT_DYNAMIC_CLASS(wxTreeEvent, wxNotifyEvent)
 
 
-wxTreeEvent::wxTreeEvent(wxEventType commandType, int id):
-  wxCommandEvent(commandType, id)
+wxTreeEvent::wxTreeEvent(wxEventType commandType, int id)
+           : wxNotifyEvent(commandType, id)
 {
     m_code = 0;
 {
     m_code = 0;
-    m_oldItem = 0;
+    m_itemOld = 0;
 }
 
 }
 
wxWidgets (Impactor)