Start "native" implementation of wxTreeCtrl for wxQT

src/qt/treectrl.cpp

@@ -7,12 +7,49 @@
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
-
 #include "wx/treectrl.h"
+#include "wx/qt/private/winevent.h"
 
 #include <QtWidgets/QTreeWidget>
 
-wxTreeCtrl::wxTreeCtrl()
+namespace
+{
+    class wxQTreeWidget : public wxQtEventSignalHandler<QTreeWidget, wxTreeCtrl>
+    {
+    public:
+        wxQTreeWidget(wxWindow *parent, wxTreeCtrl *handler) :
+            wxQtEventSignalHandler(parent, handler)
+        {      
+        }
+    };
+
+    QTreeWidgetItem *wxQtConvertTreeItem(const wxTreeItemId &item)
+    {
+        return static_cast<QTreeWidgetItem*>(item.GetID());
+    }
+
+    wxTreeItemId wxQtConvertTreeItem(QTreeWidgetItem *item)
+    {
+        return wxTreeItemId(item);
+    }
+
+    size_t CountChildren(QTreeWidgetItem *item)
+    {
+        const int currentCount = item->childCount();
+        size_t totalCount = currentCount;
+
+        for(int i = 0; i < totalCount; ++i)
+        {
+            totalCount += CountChildren(item->child(0));
+        }
+
+        return totalCount;
+    }
+
+}
+
+wxTreeCtrl::wxTreeCtrl() :
+    m_qtTreeWidget(NULL)
 {
 }
 
@@ -21,9 +58,9 @@ wxTreeCtrl::wxTreeCtrl(wxWindow *parent, wxWindowID id,
            const wxSize& size,
            long style,
            const wxValidator& validator,
-           const wxString& name)
+           const wxString& name) 
 {
-    Create( parent, id, pos, size, style, validator, name );
+    Create(parent, id, pos, size, style, validator, name);
 }
 
 bool wxTreeCtrl::Create(wxWindow *parent, wxWindowID id,
@@ -33,17 +70,16 @@ bool wxTreeCtrl::Create(wxWindow *parent, wxWindowID id,
             const wxValidator& validator,
             const wxString& name)
 {
-    m_qtTreeWidget = new QTreeWidget( parent->GetHandle() );
+    m_qtTreeWidget = new wxQTreeWidget(parent, this);
 
-    return QtCreateControl( parent, id, pos, size, style, validator, name );
+    return QtCreateControl(parent, id, pos, size, style, validator, name);
 }
 
 unsigned wxTreeCtrl::GetCount() const
 {
-    return 0;
+    return m_qtTreeWidget->topLevelItemCount();
 }
 
-
 unsigned wxTreeCtrl::GetIndent() const
 {
     return m_qtTreeWidget->columnCount();
@@ -56,247 +92,587 @@ void wxTreeCtrl::SetIndent(unsigned int indent)
 
 void wxTreeCtrl::SetImageList(wxImageList *imageList)
 {
+    m_imageListNormal = imageList;
 }
 
 void wxTreeCtrl::SetStateImageList(wxImageList *imageList)
 {
+    m_imageListState = imageList;
 }
 
 wxString wxTreeCtrl::GetItemText(const wxTreeItemId& item) const
 {
-    return wxString();
+    if (!item.IsOk())
+        return "";
+
+    QTreeWidgetItem* qTreeItem = wxQtConvertTreeItem(item);
+    return wxQtConvertString(qTreeItem->text(0));
 }
 
-int wxTreeCtrl::GetItemImage(const wxTreeItemId& item,
-                 wxTreeItemIcon which) const
+int wxTreeCtrl::GetItemImage(const wxTreeItemId& item, wxTreeItemIcon WXUNUSED(which)) const
 {
+    wxCHECK_MSG(item.IsOk(), 0, "invalid tree item");
+
     return 0;
 }
 
 wxTreeItemData *wxTreeCtrl::GetItemData(const wxTreeItemId& item) const
 {
-    return NULL;
+    wxCHECK_MSG(item.IsOk(), NULL, "invalid tree item");
+
+    QTreeWidgetItem* qTreeItem = wxQtConvertTreeItem(item);
+    QVariant itemData = qTreeItem->data(0, Qt::UserRole);
+    void* value =  itemData.value<void *>();
+    return static_cast<wxTreeItemData*>(value);
 }
 
 wxColour wxTreeCtrl::GetItemTextColour(const wxTreeItemId& item) const
 {
-    return wxColour();
+    wxCHECK_MSG(item.IsOk(), wxNullColour, "invalid tree item");
+
+    QTreeWidgetItem* qTreeItem = wxQtConvertTreeItem(item);
+    return wxQtConvertColour(qTreeItem->textColor(0));
+
 }
 
 wxColour wxTreeCtrl::GetItemBackgroundColour(const wxTreeItemId& item) const
 {
-    return wxColour();
+    wxCHECK_MSG(item.IsOk(), wxNullColour, "invalid tree item");
+
+    QTreeWidgetItem* qTreeItem = wxQtConvertTreeItem(item);
+    return wxQtConvertColour(qTreeItem->backgroundColor(0));
 }
 
 wxFont wxTreeCtrl::GetItemFont(const wxTreeItemId& item) const
 {
-    return wxFont();
+    wxCHECK_MSG(item.IsOk(), wxNullFont, "invalid tree item");
+
+    QTreeWidgetItem* qTreeItem = wxQtConvertTreeItem(item);
+    return wxFont(qTreeItem->font(0));
 }
 
 void wxTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text)
 {
+    wxCHECK_RET(item.IsOk(), "invalid tree item");
+    QTreeWidgetItem* qTreeItem = wxQtConvertTreeItem(item);
+    qTreeItem->setText(0, wxQtConvertString(text));
 }
 
-void wxTreeCtrl::SetItemImage(const wxTreeItemId& item,
-                          int image,
-                          wxTreeItemIcon which)
+void wxTreeCtrl::SetItemImage(const wxTreeItemId& item, int WXUNUSED(image), wxTreeItemIcon WXUNUSED(which))
 {
+    wxCHECK_RET(item.IsOk(), "invalid tree item");
 }
 
 void wxTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data)
 {
+    wxCHECK_RET(item.IsOk(), "invalid tree item");
+
+    if (data != NULL)
+        data->SetId(item);
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+    qTreeItem->setData(0, Qt::UserRole, QVariant::fromValue(static_cast<void*>(data)));
 }
 
 void wxTreeCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
 {
+    wxCHECK_RET(item.IsOk(), "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+    qTreeItem->setChildIndicatorPolicy(has ? QTreeWidgetItem::ShowIndicator : QTreeWidgetItem::DontShowIndicatorWhenChildless);
 }
 
 void wxTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
 {
+    wxCHECK_RET(item.IsOk(), "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+    QFont font = qTreeItem->font(0);
+    font.setBold(bold);
+    qTreeItem->setFont(0, font);
 }
 
 void wxTreeCtrl::SetItemDropHighlight(const wxTreeItemId& item, bool highlight)
 {
+    wxCHECK_RET(item.IsOk(), "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+
+    wxColour fg, bg;
+
+    if (highlight)
+    {
+        bg = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
+        fg = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
+    }
+    else
+    {
+        bg = GetBackgroundColour();
+        fg = GetForegroundColour();
+    }
+
+    qTreeItem->setBackgroundColor(0, wxQtConvertColour(bg));
+    qTreeItem->setTextColor(0, wxQtConvertColour(fg));
 }
 
 void wxTreeCtrl::SetItemTextColour(const wxTreeItemId& item, const wxColour& col)
 {
+    wxCHECK_RET(item.IsOk(), "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+    qTreeItem->setTextColor(0, wxQtConvertColour(col));
 }
 
 void wxTreeCtrl::SetItemBackgroundColour(const wxTreeItemId& item, const wxColour& col)
 {
+    wxCHECK_RET(item.IsOk(), "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+    qTreeItem->setTextColor(0, wxQtConvertColour(col));
 }
 
 void wxTreeCtrl::SetItemFont(const wxTreeItemId& item, const wxFont& font)
 {
+    wxCHECK_RET(item.IsOk(), "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+    qTreeItem->setFont(0, font.GetHandle());
 }
 
 bool wxTreeCtrl::IsVisible(const wxTreeItemId& item) const
 {
-    return false;
+    wxCHECK_MSG(item.IsOk(), false, "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+    const QRect visualRect = m_qtTreeWidget->visualItemRect(qTreeItem);
+    return visualRect.isValid();
 }
 
 bool wxTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const
 {
-    return false;
+    wxCHECK_MSG(item.IsOk(), false, "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+    return qTreeItem->childCount() > 0;
 }
 
 bool wxTreeCtrl::IsExpanded(const wxTreeItemId& item) const
 {
-    return false;
+    wxCHECK_MSG(item.IsOk(), false, "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+    return qTreeItem->isExpanded();
 }
 
 bool wxTreeCtrl::IsSelected(const wxTreeItemId& item) const
 {
-    return false;
+    wxCHECK_MSG(item.IsOk(), false, "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+    return qTreeItem->isSelected();
 }
 
 bool wxTreeCtrl::IsBold(const wxTreeItemId& item) const
 {
-    return false;
+    wxCHECK_MSG(item.IsOk(), false, "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+    QFont font = qTreeItem->font(0);
+    return font.bold();
 }
 
 size_t wxTreeCtrl::GetChildrenCount(const wxTreeItemId& item, bool recursively) const
 {
-    return 0;
+    wxCHECK_MSG(item.IsOk(), 0, "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+
+    if (recursively)
+        return CountChildren(qTreeItem);
+
+    return qTreeItem->childCount();
 }
 
 wxTreeItemId wxTreeCtrl::GetRootItem() const
 {
-    return wxTreeItemId();
+    QTreeWidgetItem *root = m_qtTreeWidget->invisibleRootItem();
+    if (HasFlag(wxTR_HIDE_ROOT))
+    {
+        return wxQtConvertTreeItem(root);
+    }
+
+    if (root->childCount() == 0)
+        return wxTreeItemId();
+
+    return wxQtConvertTreeItem(root->child(0));
 }
 
 wxTreeItemId wxTreeCtrl::GetSelection() const
 {
-    return wxTreeItemId();
+    QList<QTreeWidgetItem*> selections = m_qtTreeWidget->selectedItems();
+    return selections.isEmpty() ? wxTreeItemId() : wxQtConvertTreeItem(selections[0]);
+
 }
 
 size_t wxTreeCtrl::GetSelections(wxArrayTreeItemIds& selections) const
 {
-    return 0;
+    QList<QTreeWidgetItem*> qtSelections = m_qtTreeWidget->selectedItems();
+
+    const size_t numberOfSelections = qtSelections.size();
+    selections.SetCount(numberOfSelections);
+
+    for (size_t i = 0; i < numberOfSelections; ++i)
+    {
+        selections[i] = qtSelections[i];
+    }
+
+    return numberOfSelections;
 }
 
 void wxTreeCtrl::SetFocusedItem(const wxTreeItemId& item)
 {
-
+    wxCHECK_RET(item.IsOk(), "invalid tree item");
+    m_qtTreeWidget->setCurrentItem(wxQtConvertTreeItem(item), 0);
 }
 
 void wxTreeCtrl::ClearFocusedItem()
 {
-
+    QTreeWidgetItem *current = m_qtTreeWidget->currentItem();
+    if (current != NULL)
+        current->setSelected(false);
 }
 
 wxTreeItemId wxTreeCtrl::GetFocusedItem() const
 {
-    return wxTreeItemId();
+    return wxQtConvertTreeItem(m_qtTreeWidget->currentItem());
 }
 
 wxTreeItemId wxTreeCtrl::GetItemParent(const wxTreeItemId& item) const
 {
-    return wxTreeItemId();
+    wxCHECK_MSG(item.IsOk(), wxTreeItemId(), "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+    return wxQtConvertTreeItem(qTreeItem->parent());
 }
 
 wxTreeItemId wxTreeCtrl::GetFirstChild(const wxTreeItemId& item, wxTreeItemIdValue& cookie) const
 {
-    return wxTreeItemId();
+    wxCHECK_MSG(item.IsOk(), wxTreeItemId(), "invalid tree item");
+
+    cookie = 0;
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+
+    return qTreeItem->childCount() > 0 ? wxQtConvertTreeItem(qTreeItem->child(0)) : wxTreeItemId();
 }
 
 wxTreeItemId wxTreeCtrl::GetNextChild(const wxTreeItemId& item, wxTreeItemIdValue& cookie) const
 {
+    wxCHECK_MSG(item.IsOk(), wxTreeItemId(), "invalid tree item");
+
+    int currentIndex = reinterpret_cast<int>(cookie);
+    ++currentIndex;
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+
+    if ( currentIndex < qTreeItem->childCount() )
+    {
+        cookie = reinterpret_cast<wxTreeItemIdValue>(currentIndex);
+        return wxQtConvertTreeItem(qTreeItem->child(currentIndex));
+    }
+
     return wxTreeItemId();
 }
 
 wxTreeItemId wxTreeCtrl::GetLastChild(const wxTreeItemId& item) const
 {
-    return wxTreeItemId();
+    wxCHECK_MSG(item.IsOk(), wxTreeItemId(), "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+    const int childCount = qTreeItem->childCount();
+    return childCount == 0 ? wxTreeItemId() : wxQtConvertTreeItem(qTreeItem->child(childCount - 1));
 }
 
 wxTreeItemId wxTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
 {
-    return wxTreeItemId();
+    wxCHECK_MSG(item.IsOk(), wxTreeItemId(), "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+    QTreeWidgetItem *parent = qTreeItem->parent();
+
+    if ( parent != NULL )
+    {
+        int index = parent->indexOfChild(qTreeItem);
+        wxASSERT(index != -1);
+
+        ++index;
+        return index < parent->childCount() ? wxQtConvertTreeItem(parent->child(index)) : wxTreeItemId();
+    }
+
+    int index = m_qtTreeWidget->indexOfTopLevelItem(qTreeItem);
+    wxASSERT(index != -1);
+
+    ++index;
+    return index < m_qtTreeWidget->topLevelItemCount() ? wxQtConvertTreeItem(m_qtTreeWidget->topLevelItem(index)) : wxTreeItemId();
 }
 
 wxTreeItemId wxTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const
 {
-    return wxTreeItemId();
+    wxCHECK_MSG(item.IsOk(), wxTreeItemId(), "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+    QTreeWidgetItem *parent = qTreeItem->parent();
+
+    if (parent != NULL)
+    {
+        int index = parent->indexOfChild(qTreeItem);
+        wxASSERT(index != -1);
+
+        --index;
+        return index >= 0 ? wxQtConvertTreeItem(parent->child(index)) : wxTreeItemId();
+    }
+
+    int index = m_qtTreeWidget->indexOfTopLevelItem(qTreeItem);
+    wxASSERT(index != -1);
+
+    --index;
+    return index >= 0 ? wxQtConvertTreeItem(m_qtTreeWidget->topLevelItem(index)) : wxTreeItemId();
 }
 
 wxTreeItemId wxTreeCtrl::GetFirstVisibleItem() const
 {
+   wxTreeItemId itemid = GetRootItem();
+    if (!itemid.IsOk())
+        return itemid;
+    do
+    {
+        if (IsVisible(itemid))
+            return itemid;
+        itemid = GetNext(itemid);
+    } while (itemid.IsOk());
+
     return wxTreeItemId();
 }
 
 wxTreeItemId wxTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
 {
+    wxCHECK_MSG(item.IsOk(), wxTreeItemId(), wxT("invalid tree item"));
+    wxASSERT_MSG(IsVisible(item), wxT("this item itself should be visible"));
+
+    wxTreeItemId id = item;
+    if (id.IsOk())
+    {
+        while (id = GetNext(id), id.IsOk())
+        {
+            if (IsVisible(id))
+                return id;
+        }
+    }
     return wxTreeItemId();
 }
 
 wxTreeItemId wxTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
 {
-    return wxTreeItemId();
+    wxCHECK_MSG(item.IsOk(), wxTreeItemId(), wxT("invalid tree item"));
+    wxASSERT_MSG(IsVisible(item), wxT("this item itself should be visible"));
+
+    // find out the starting point
+    wxTreeItemId prevItem = GetPrevSibling(item);
+    if (!prevItem.IsOk())
+    {
+        prevItem = GetItemParent(item);
+    }
+
+    // find the first visible item after it
+    while (prevItem.IsOk() && !IsVisible(prevItem))
+    {
+        prevItem = GetNext(prevItem);
+        if (!prevItem.IsOk() || prevItem == item)
+        {
+            // there are no visible items before item
+            return wxTreeItemId();
+        }
+    }
+
+    // from there we must be able to navigate until this item
+    while (prevItem.IsOk())
+    {
+        const wxTreeItemId nextItem = GetNextVisible(prevItem);
+        if (!nextItem.IsOk() || nextItem == item)
+            break;
+
+        prevItem = nextItem;
+    }
+
+    return prevItem;
 }
 
 wxTreeItemId wxTreeCtrl::AddRoot(const wxString& text,
                              int image, int selImage,
                              wxTreeItemData *data)
 {
-    return wxTreeItemId();
+    QTreeWidgetItem *item = m_qtTreeWidget->invisibleRootItem();
+
+    if ( HasFlag(wxTR_HIDE_ROOT) )
+    {
+        item->setText(0, wxQtConvertString(text));
+        return wxQtConvertTreeItem(item);
+    }
+
+    return DoInsertItem(wxQtConvertTreeItem(item), 0, text, image, selImage, data);
 }
 
 void wxTreeCtrl::Delete(const wxTreeItemId& item)
 {
+    wxCHECK_RET(item.IsOk(), "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+    QTreeWidgetItem *parent = qTreeItem->parent();
+
+    if ( parent != NULL )
+    {
+        parent->removeChild(qTreeItem);
+    }
+    else
+    {
+        m_qtTreeWidget->removeItemWidget(qTreeItem, 0);
+    }
+
+    SendDeleteEvent(item);
+
+    delete qTreeItem;
 }
 
 void wxTreeCtrl::DeleteChildren(const wxTreeItemId& item)
 {
+    wxCHECK_RET(item.IsOk(), "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+    while (qTreeItem->childCount() > 0)
+    {
+        QTreeWidgetItem *child = qTreeItem->child(0);
+        DeleteChildren(wxQtConvertTreeItem(child));
+        qTreeItem->removeChild(child);
+
+        SendDeleteEvent(wxQtConvertTreeItem(child));
+
+        delete child;
+    }
 }
 
 void wxTreeCtrl::DeleteAllItems()
 {
+    DeleteChildren(wxQtConvertTreeItem(m_qtTreeWidget->invisibleRootItem()));
 }
 
 void wxTreeCtrl::Expand(const wxTreeItemId& item)
 {
+    wxCHECK_RET(item.IsOk(), "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+    qTreeItem->setExpanded(true);
 }
 
 void wxTreeCtrl::Collapse(const wxTreeItemId& item)
 {
+    wxCHECK_RET(item.IsOk(), "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+    qTreeItem->setExpanded(false);
 }
 
 void wxTreeCtrl::CollapseAndReset(const wxTreeItemId& item)
 {
+    wxCHECK_RET(item.IsOk(), "invalid tree item");
+
+    Collapse(item);
+    DeleteChildren(item);
 }
 
 void wxTreeCtrl::Toggle(const wxTreeItemId& item)
 {
+    wxCHECK_RET(item.IsOk(), "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+    qTreeItem->setSelected(!qTreeItem->isSelected());
 }
 
 void wxTreeCtrl::Unselect()
 {
+    QTreeWidgetItem *current = m_qtTreeWidget->currentItem();
+
+    if (current != NULL)
+        current->setSelected(false);
 }
 
 void wxTreeCtrl::UnselectAll()
 {
+    QList<QTreeWidgetItem *> selections = m_qtTreeWidget->selectedItems();
+    const size_t selectedCount = selections.size();
+    for ( size_t i = 0; i < selectedCount; ++i)
+    {
+        selections[i]->setSelected(false);
+    }
 }
 
 void wxTreeCtrl::SelectItem(const wxTreeItemId& item, bool select)
 {
+    wxCHECK_RET(item.IsOk(), "invalid tree item");
+
+    if ( !HasFlag(wxTR_MULTIPLE) )
+    {
+        QList<QTreeWidgetItem *> selections = m_qtTreeWidget->selectedItems();
+        const size_t nSelections = selections.size();
+
+        for (size_t i = 0; i < nSelections; ++i)
+        {
+            selections[i]->setSelected(false);
+        }
+    }
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+    qTreeItem->setSelected(select);
 }
 
 void wxTreeCtrl::SelectChildren(const wxTreeItemId& parent)
 {
+    wxCHECK_RET(parent.IsOk(), "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(parent);
+    const int childCount = qTreeItem->childCount();
+
+    for (int i = 0; i < childCount; ++i)
+    {
+        qTreeItem->child(i)->setSelected(true);
+    }
 }
 
 void wxTreeCtrl::EnsureVisible(const wxTreeItemId& item)
 {
+    wxCHECK_RET(item.IsOk(), "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+    QTreeWidgetItem *parent = qTreeItem->parent();
+
+    while ( parent != NULL )
+    {
+        parent->setExpanded(true);
+        parent = parent->parent();
+    }
+
+    ScrollTo(item);
 }
 
 void wxTreeCtrl::ScrollTo(const wxTreeItemId& item)
 {
+    wxCHECK_RET(item.IsOk(), "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+    m_qtTreeWidget->scrollToItem(qTreeItem);
 }
 
 wxTextCtrl *wxTreeCtrl::EditLabel(const wxTreeItemId& item, wxClassInfo* textCtrlClass)
 {
+    wxCHECK_MSG(item.IsOk(), NULL, "invalid tree item");
     return NULL;
 }
 
@@ -307,24 +683,32 @@ wxTextCtrl *wxTreeCtrl::GetEditControl() const
 
 void wxTreeCtrl::EndEditLabel(const wxTreeItemId& item, bool discardChanges)
 {
+    wxCHECK_RET(item.IsOk(), "invalid tree item");
 }
 
 void wxTreeCtrl::SortChildren(const wxTreeItemId& item)
 {
+    wxCHECK_RET(item.IsOk(), "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+    qTreeItem->sortChildren(0, Qt::AscendingOrder);
 }
 
 bool wxTreeCtrl::GetBoundingRect(const wxTreeItemId& item, wxRect& rect, bool textOnly) const
 {
+    wxCHECK_MSG(item.IsOk(), false, "invalid tree item");
     return false;
 }
 
 int wxTreeCtrl::DoGetItemState(const wxTreeItemId& item) const
 {
+    wxCHECK_MSG(item.IsOk(), wxTREE_ITEMSTATE_NONE, "invalid tree item");
     return 0;
 }
 
 void wxTreeCtrl::DoSetItemState(const wxTreeItemId& item, int state)
 {
+    wxCHECK_RET(item.IsOk(), "invalid tree item");
 }
 
 wxTreeItemId wxTreeCtrl::DoInsertItem(const wxTreeItemId& parent,
@@ -333,7 +717,29 @@ wxTreeItemId wxTreeCtrl::DoInsertItem(const wxTreeItemId& parent,
                                   int image, int selImage,
                                   wxTreeItemData *data)
 {
-    return wxTreeItemId();
+    wxCHECK_MSG(parent.IsOk(), wxTreeItemId(), "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(parent);
+
+    QTreeWidgetItem *newItem = new QTreeWidgetItem;
+    newItem->setText(0, wxQtConvertString(text));
+    newItem->setData(0, Qt::UserRole, QVariant::fromValue(static_cast<void*>(data)));
+
+    if (pos == static_cast<size_t>(-1))
+    {
+        qTreeItem->addChild(newItem);
+    }
+    else
+    {
+        qTreeItem->insertChild(pos, newItem);
+    }
+
+    wxTreeItemId wxItem = wxQtConvertTreeItem(newItem);
+
+    if (data != NULL)
+        data->SetId(wxItem);
+
+    return wxItem;
 }
 
 wxTreeItemId wxTreeCtrl::DoInsertAfter(const wxTreeItemId& parent,
@@ -342,15 +748,64 @@ wxTreeItemId wxTreeCtrl::DoInsertAfter(const wxTreeItemId& parent,
                                    int image, int selImage,
                                    wxTreeItemData *data)
 {
-    return wxTreeItemId();
+    wxCHECK_MSG(parent.IsOk(), wxTreeItemId(), "invalid tree item");
+    wxCHECK_MSG(idPrevious.IsOk(), wxTreeItemId(), "invalid tree item");
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(parent);
+    const int index = qTreeItem->indexOfChild(wxQtConvertTreeItem(idPrevious));
+    return DoInsertItem(parent, index + 1, text, image, selImage, data);
 }
 
 wxTreeItemId wxTreeCtrl::DoTreeHitTest(const wxPoint& point, int& flags) const
 {
-    return wxTreeItemId();
+    int w, h;
+    GetSize(&w, &h);
+    flags = 0;
+    if (point.x < 0) flags |= wxTREE_HITTEST_TOLEFT;
+    if (point.x > w) flags |= wxTREE_HITTEST_TORIGHT;
+    if (point.y < 0) flags |= wxTREE_HITTEST_ABOVE;
+    if (point.y > h) flags |= wxTREE_HITTEST_BELOW;
+    if (flags) return wxTreeItemId();
+
+    QTreeWidgetItem *hitItem = m_qtTreeWidget->itemAt(wxQtConvertPoint(point));
+
+    if (hitItem == NULL)
+        flags |= wxTREE_HITTEST_NOWHERE;
+
+    return wxQtConvertTreeItem(hitItem);
 }
 
 QWidget *wxTreeCtrl::GetHandle() const
 {
     return m_qtTreeWidget;
 }
+
+void wxTreeCtrl::SendDeleteEvent(const wxTreeItemId &item)
+{
+    wxTreeEvent event(wxEVT_TREE_DELETE_ITEM, GetId());
+    event.SetItem(item);
+    HandleWindowEvent(event);
+}
+
+wxTreeItemId wxTreeCtrl::GetNext(const wxTreeItemId &item) const
+{
+    wxCHECK_MSG(item.IsOk(), wxTreeItemId(), wxT("invalid tree item"));
+
+    QTreeWidgetItem *qTreeItem = wxQtConvertTreeItem(item);
+
+    if ( qTreeItem->childCount() > 0)
+    {
+        return qTreeItem->child(0);
+    }
+    
+    // Try a sibling of this or ancestor instead
+    wxTreeItemId p = item;
+    wxTreeItemId toFind;
+    do
+    {
+        toFind = GetNextSibling(p);
+        p = GetItemParent(p);
+    } while (p.IsOk() && !toFind.IsOk());
+    return toFind;
+}
+