TreeHierarchyTab.cpp

Go to the documentation of this file.

#include "Tabs/TreeHierarchyTab.h"
#include <algorithm>
#include <functional>
 
namespace EmberUI {
 
wxBEGIN_EVENT_TABLE(TreeHierarchyTab, wxPanel)
    EVT_TREE_ITEM_EXPANDING(TreeHierarchyTab::ID_TREE_CTRL, TreeHierarchyTab::OnTreeItemExpanding)
        EVT_TREE_ITEM_COLLAPSING(TreeHierarchyTab::ID_TREE_CTRL, TreeHierarchyTab::OnTreeItemCollapsing)
            EVT_TREE_SEL_CHANGED(TreeHierarchyTab::ID_TREE_CTRL, TreeHierarchyTab::OnTreeSelectionChanged)
                EVT_TREE_ITEM_RIGHT_CLICK(TreeHierarchyTab::ID_TREE_CTRL, TreeHierarchyTab::OnTreeItemRightClick)
                    EVT_TREE_ITEM_ACTIVATED(TreeHierarchyTab::ID_TREE_CTRL, TreeHierarchyTab::OnTreeItemActivated)
                        EVT_TEXT(TreeHierarchyTab::ID_SEARCH_CTRL, TreeHierarchyTab::OnSearchTextChanged)
                            EVT_SEARCHCTRL_SEARCH_BTN(TreeHierarchyTab::ID_SEARCH_CTRL, TreeHierarchyTab::OnSearchEnter)
                                EVT_TEXT_ENTER(TreeHierarchyTab::ID_SEARCH_CTRL, TreeHierarchyTab::OnSearchEnter)
                                    wxEND_EVENT_TABLE()
 
                                        TreeHierarchyTab::TreeHierarchyTab(wxWindow *parent,
                                                                           const TreeHierarchyConfig &config)
    : wxPanel(parent, wxID_ANY), m_config(config) {
    SetBackgroundColour(m_config.panelColour);
    CreateLayout();
}
 
void TreeHierarchyTab::CreateLayout() {
    m_mainSizer = new wxBoxSizer(wxVERTICAL);
 
    m_searchCtrl = new wxSearchCtrl(this, ID_SEARCH_CTRL, "", wxDefaultPosition, wxDefaultSize);
    m_searchCtrl->SetDescriptiveText("Search nodes...");
    m_searchCtrl->ShowSearchButton(true);
    m_searchCtrl->ShowCancelButton(true);
    if (!m_config.showSearchBar) {
        m_searchCtrl->Hide();
    }
 
    long treeStyle = wxTR_HAS_BUTTONS | wxTR_MULTIPLE;
    if (!m_config.showTreeLines) {
        treeStyle |= wxTR_NO_LINES;
    }
 
    m_treeCtrl = new wxTreeCtrl(this, ID_TREE_CTRL, wxDefaultPosition, wxDefaultSize, treeStyle);
    m_treeCtrl->SetBackgroundColour(m_config.backgroundColour);
    m_treeCtrl->SetForegroundColour(m_config.foregroundColour);
    m_treeCtrl->SetIndent(m_config.treeIndentationSize);
 
    wxFont treeFont = m_treeCtrl->GetFont();
    treeFont.SetPointSize(m_config.fontSize);
    m_treeCtrl->SetFont(treeFont);
 
    m_mainSizer->Add(m_searchCtrl, 0, wxLEFT | wxRIGHT | wxEXPAND, 10);
    m_mainSizer->AddSpacer(5);
    m_mainSizer->Add(m_treeCtrl, 1, wxLEFT | wxRIGHT | wxEXPAND, 10);
    m_mainSizer->AddSpacer(10);
 
    SetSizer(m_mainSizer);
}
 
void TreeHierarchyTab::ApplyConfig(const TreeHierarchyConfig &config) {
    m_config = config;
 
    if (m_searchCtrl) {
        m_searchCtrl->Show(m_config.showSearchBar);
    }
 
    if (m_treeCtrl) {
        m_treeCtrl->SetBackgroundColour(m_config.backgroundColour);
        m_treeCtrl->SetForegroundColour(m_config.foregroundColour);
        m_treeCtrl->SetIndent(m_config.treeIndentationSize);
        wxFont f = m_treeCtrl->GetFont();
        f.SetPointSize(m_config.fontSize);
        m_treeCtrl->SetFont(f);
    }
 
    Layout();
}
 
// --- Tree management ---
 
void TreeHierarchyTab::SetTree(std::shared_ptr<EmberCore::ITreeStructure> tree) {
    m_tree = std::move(tree);
    m_searchFilter.Clear();
    if (m_searchCtrl) {
        m_searchCtrl->ChangeValue("");
    }
    PopulateTree();
}
 
void TreeHierarchyTab::ClearTree() {
    m_tree.reset();
    m_treeCtrl->DeleteAllItems();
    m_lastSelectedItem = wxTreeItemId();
}
 
void TreeHierarchyTab::RefreshTree() {
    m_lastSelectedItem = wxTreeItemId();
    m_isRefreshing = true;
    PopulateTree();
    m_isRefreshing = false;
}
 
void TreeHierarchyTab::PopulateTree() {
    m_treeCtrl->Freeze();
    m_treeCtrl->DeleteAllItems();
 
    if (!m_tree || !m_tree->HasRootNode()) {
        m_treeCtrl->Thaw();
        return;
    }
 
    EmberCore::ITreeNode *root = m_tree->GetRootNode();
    wxTreeItemId rootItem = m_treeCtrl->AddRoot(GetNodeDisplayText(root));
    m_treeCtrl->SetItemData(rootItem, new TreeNodeItemData(root));
 
    if (!m_searchFilter.IsEmpty()) {
        AddFilteredNodes(rootItem, root);
    } else {
        AddChildrenToItem(rootItem, root);
    }
 
    if (m_isRefreshing) {
        ExpandTreeByVisibility(rootItem);
    } else if (m_config.autoExpandOnLoad || !m_searchFilter.IsEmpty()) {
        ExpandTreeToDepth(rootItem, m_config.autoExpandDepth);
    }
 
    m_treeCtrl->UnselectAll();
    m_treeCtrl->Thaw();
}
 
void TreeHierarchyTab::AddFilteredNodes(const wxTreeItemId &parentItem, EmberCore::ITreeNode *node) {
    if (!node)
        return;
 
    for (size_t i = 0; i < node->GetChildCount(); ++i) {
        EmberCore::ITreeNode *child = node->GetChild(i);
        if (!child)
            continue;
 
        wxString nodeName = wxString(child->GetName().c_str()).Lower();
        wxString searchLower = m_searchFilter.Lower();
        if (nodeName.Find(searchLower) == wxNOT_FOUND)
            continue;
 
        wxTreeItemId childItem = m_treeCtrl->AppendItem(parentItem, GetNodeDisplayText(child));
        m_treeCtrl->SetItemData(childItem, new TreeNodeItemData(child));
 
        AddFilteredNodes(childItem, child);
    }
}
 
void TreeHierarchyTab::AddChildrenToItem(const wxTreeItemId &parentItem, EmberCore::ITreeNode *node) {
    if (!node)
        return;
 
    for (size_t i = 0; i < node->GetChildCount(); ++i) {
        EmberCore::ITreeNode *child = node->GetChild(i);
        if (!child)
            continue;
 
        wxTreeItemId childItem = m_treeCtrl->AppendItem(parentItem, GetNodeDisplayText(child));
        m_treeCtrl->SetItemData(childItem, new TreeNodeItemData(child));
 
        if (child->HasChildren()) {
            m_treeCtrl->AppendItem(childItem, "", -1, -1, new DummyTreeItemData());
        }
    }
}
 
void TreeHierarchyTab::ExpandTreeToDepth(const wxTreeItemId &item, int remainingDepth) {
    if (remainingDepth <= 0 || !item.IsOk())
        return;
 
    if (!m_treeCtrl->ItemHasChildren(item))
        return;
 
    wxTreeItemIdValue checkCookie;
    wxTreeItemId firstChild = m_treeCtrl->GetFirstChild(item, checkCookie);
    if (firstChild.IsOk()) {
        wxTreeItemData *data = m_treeCtrl->GetItemData(firstChild);
        if (dynamic_cast<DummyTreeItemData *>(data)) {
            EmberCore::ITreeNode *node = GetNodeFromItem(item);
            if (node) {
                m_treeCtrl->DeleteChildren(item);
                AddChildrenToItem(item, node);
            }
        }
    }
 
    m_treeCtrl->Expand(item);
 
    wxTreeItemIdValue cookie;
    wxTreeItemId child = m_treeCtrl->GetFirstChild(item, cookie);
    while (child.IsOk()) {
        ExpandTreeToDepth(child, remainingDepth - 1);
        child = m_treeCtrl->GetNextChild(item, cookie);
    }
}
 
void TreeHierarchyTab::ExpandTreeByVisibility(const wxTreeItemId &item) {
    if (!item.IsOk() || !m_treeCtrl->ItemHasChildren(item))
        return;
 
    EmberCore::ITreeNode *node = GetNodeFromItem(item);
    if (!node || !node->AreChildrenVisible())
        return;
 
    wxTreeItemIdValue checkCookie;
    wxTreeItemId firstChild = m_treeCtrl->GetFirstChild(item, checkCookie);
    if (firstChild.IsOk()) {
        wxTreeItemData *data = m_treeCtrl->GetItemData(firstChild);
        if (dynamic_cast<DummyTreeItemData *>(data)) {
            m_treeCtrl->DeleteChildren(item);
            AddChildrenToItem(item, node);
        }
    }
 
    m_treeCtrl->Expand(item);
 
    wxTreeItemIdValue cookie;
    wxTreeItemId child = m_treeCtrl->GetFirstChild(item, cookie);
    while (child.IsOk()) {
        ExpandTreeByVisibility(child);
        child = m_treeCtrl->GetNextChild(item, cookie);
    }
}
 
void TreeHierarchyTab::ExpandAll() { m_treeCtrl->ExpandAll(); }
 
void TreeHierarchyTab::CollapseAll() { m_treeCtrl->CollapseAll(); }
 
// --- Selection ---
 
EmberCore::ITreeNode *TreeHierarchyTab::GetSelectedNode() const {
    wxArrayTreeItemIds selections;
    size_t count = m_treeCtrl->GetSelections(selections);
    if (count > 0) {
        return GetNodeFromItem(selections[0]);
    }
    return nullptr;
}
 
void TreeHierarchyTab::SelectNodeById(size_t nodeId) {
    if (!m_config.syncSelectionWithCanvas)
        return;
 
    wxTreeItemId item = FindItemById(nodeId);
 
    if (!item.IsOk()) {
        EmberCore::ITreeNode *node = m_tree ? m_tree->FindNodeById(nodeId) : nullptr;
        if (node) {
            item = ExpandPathToNode(node);
        }
    }
 
    if (item.IsOk()) {
        m_treeCtrl->UnselectAll();
        m_treeCtrl->SelectItem(item);
        ScrollToItemHorizontally(item);
    }
}
 
// --- Virtual hooks (default implementations) ---
 
wxString TreeHierarchyTab::GetNodeDisplayText(EmberCore::ITreeNode *node) const {
    if (!node)
        return "Unknown Node";
    return node->GetName();
}
 
void TreeHierarchyTab::OnSelectionChanged(EmberCore::ITreeNode *node) {
    if (m_selectionCallback) {
        m_selectionCallback(node);
    }
}
 
void TreeHierarchyTab::OnNodeExpanding(EmberCore::ITreeNode *node) {
    if (node) {
        node->SetChildrenVisible(true);
    }
}
 
void TreeHierarchyTab::OnNodeCollapsing(EmberCore::ITreeNode *node) {
    if (node) {
        node->SetChildrenVisible(false);
    }
}
 
// --- Utility ---
 
EmberCore::ITreeNode *TreeHierarchyTab::GetNodeFromItem(const wxTreeItemId &item) const {
    if (!item.IsOk())
        return nullptr;
 
    TreeNodeItemData *data = dynamic_cast<TreeNodeItemData *>(m_treeCtrl->GetItemData(item));
    if (!data)
        return nullptr;
 
    return data->node;
}
 
wxTreeItemId TreeHierarchyTab::FindItemById(size_t nodeId, const wxTreeItemId &start) {
    wxTreeItemId searchStart = start.IsOk() ? start : m_treeCtrl->GetRootItem();
    if (!searchStart.IsOk())
        return wxTreeItemId();
 
    EmberCore::ITreeNode *currentNode = GetNodeFromItem(searchStart);
    if (currentNode && currentNode->GetId() == nodeId) {
        return searchStart;
    }
 
    wxTreeItemIdValue cookie;
    wxTreeItemId child = m_treeCtrl->GetFirstChild(searchStart, cookie);
    while (child.IsOk()) {
        wxTreeItemId found = FindItemById(nodeId, child);
        if (found.IsOk())
            return found;
        child = m_treeCtrl->GetNextChild(searchStart, cookie);
    }
 
    return wxTreeItemId();
}
 
wxTreeItemId TreeHierarchyTab::ExpandPathToNode(EmberCore::ITreeNode *node) {
    if (!node || !m_tree || !m_tree->HasRootNode())
        return wxTreeItemId();
 
    // Build path from root to target
    std::vector<EmberCore::ITreeNode *> path;
    EmberCore::ITreeNode *current = node;
    while (current) {
        path.push_back(current);
        current = current->GetParent();
    }
    std::reverse(path.begin(), path.end());
 
    wxTreeItemId currentItem = m_treeCtrl->GetRootItem();
    if (!currentItem.IsOk())
        return wxTreeItemId();
 
    EmberCore::ITreeNode *rootNode = GetNodeFromItem(currentItem);
    if (!rootNode || rootNode->GetId() != path[0]->GetId())
        return wxTreeItemId();
 
    for (size_t i = 1; i < path.size(); ++i) {
        // Perform lazy loading if needed
        wxTreeItemIdValue checkCookie;
        wxTreeItemId firstChild = m_treeCtrl->GetFirstChild(currentItem, checkCookie);
        if (firstChild.IsOk() && dynamic_cast<DummyTreeItemData *>(m_treeCtrl->GetItemData(firstChild))) {
            EmberCore::ITreeNode *parentNode = GetNodeFromItem(currentItem);
            if (parentNode) {
                m_treeCtrl->DeleteChildren(currentItem);
                AddChildrenToItem(currentItem, parentNode);
            }
        }
 
        if (!m_treeCtrl->IsExpanded(currentItem) && m_treeCtrl->ItemHasChildren(currentItem)) {
            m_treeCtrl->Expand(currentItem);
        }
 
        wxTreeItemIdValue cookie;
        wxTreeItemId child = m_treeCtrl->GetFirstChild(currentItem, cookie);
        bool found = false;
        while (child.IsOk()) {
            EmberCore::ITreeNode *childNode = GetNodeFromItem(child);
            if (childNode && childNode->GetId() == path[i]->GetId()) {
                currentItem = child;
                found = true;
                break;
            }
            child = m_treeCtrl->GetNextChild(currentItem, cookie);
        }
        if (!found)
            return wxTreeItemId();
    }
 
    return currentItem;
}
 
void TreeHierarchyTab::ScrollToItemHorizontally(const wxTreeItemId &item) {
    if (!item.IsOk())
        return;
 
    m_treeCtrl->EnsureVisible(item);
 
    wxRect itemRect;
    if (!m_treeCtrl->GetBoundingRect(item, itemRect, true))
        return;
 
    int clientWidth = m_treeCtrl->GetClientSize().GetWidth();
    int margin = 8;
 
    if (itemRect.x < margin) {
        int pos = m_treeCtrl->GetScrollPos(wxHORIZONTAL);
        m_treeCtrl->SetScrollPos(wxHORIZONTAL, std::max(0, pos - (margin - itemRect.x)), true);
        m_treeCtrl->Refresh();
    } else if (itemRect.x > clientWidth - 100) {
        int pos = m_treeCtrl->GetScrollPos(wxHORIZONTAL);
        m_treeCtrl->SetScrollPos(wxHORIZONTAL, pos + (itemRect.x - margin), true);
        m_treeCtrl->Refresh();
    }
}
 
void TreeHierarchyTab::SelectRange(const wxTreeItemId &from, const wxTreeItemId &to) {
    if (!from.IsOk() || !to.IsOk())
        return;
 
    std::vector<wxTreeItemId> allItems;
    std::function<void(const wxTreeItemId &)> collectItems = [&](const wxTreeItemId &item) {
        if (!item.IsOk())
            return;
        allItems.push_back(item);
        if (m_treeCtrl->IsExpanded(item)) {
            wxTreeItemIdValue cookie;
            wxTreeItemId child = m_treeCtrl->GetFirstChild(item, cookie);
            while (child.IsOk()) {
                collectItems(child);
                child = m_treeCtrl->GetNextChild(item, cookie);
            }
        }
    };
 
    wxTreeItemId root = m_treeCtrl->GetRootItem();
    if (root.IsOk()) {
        collectItems(root);
    }
 
    int fromIdx = -1, toIdx = -1;
    for (size_t i = 0; i < allItems.size(); ++i) {
        if (allItems[i] == from)
            fromIdx = static_cast<int>(i);
        if (allItems[i] == to)
            toIdx = static_cast<int>(i);
    }
 
    if (fromIdx < 0 || toIdx < 0)
        return;
 
    if (fromIdx > toIdx)
        std::swap(fromIdx, toIdx);
 
    m_treeCtrl->UnselectAll();
    for (int i = fromIdx; i <= toIdx; ++i) {
        m_treeCtrl->SelectItem(allItems[i], true);
    }
 
    m_lastSelectedItem = to;
}
 
// --- Event handlers ---
 
void TreeHierarchyTab::OnTreeItemExpanding(wxTreeEvent &event) {
    wxTreeItemId item = event.GetItem();
    EmberCore::ITreeNode *node = GetNodeFromItem(item);
    if (!node) {
        event.Skip();
        return;
    }
 
    if (!m_isRefreshing)
        OnNodeExpanding(node);
 
    wxTreeItemIdValue cookie;
    wxTreeItemId firstChild = m_treeCtrl->GetFirstChild(item, cookie);
    if (firstChild.IsOk()) {
        wxTreeItemData *data = m_treeCtrl->GetItemData(firstChild);
        if (dynamic_cast<DummyTreeItemData *>(data)) {
            m_treeCtrl->Freeze();
            m_treeCtrl->DeleteChildren(item);
            AddChildrenToItem(item, node);
            m_treeCtrl->Thaw();
        }
    }
 
    if (!m_isRefreshing && m_layoutInvalidationCb)
        m_layoutInvalidationCb();
 
    event.Skip();
}
 
void TreeHierarchyTab::OnTreeItemCollapsing(wxTreeEvent &event) {
    EmberCore::ITreeNode *node = GetNodeFromItem(event.GetItem());
 
    if (!m_isRefreshing)
        OnNodeCollapsing(node);
 
    if (!m_isRefreshing && m_layoutInvalidationCb)
        m_layoutInvalidationCb();
 
    event.Skip();
}
 
void TreeHierarchyTab::OnTreeSelectionChanged(wxTreeEvent &event) {
    wxTreeItemId selectedItem = event.GetItem();
    if (!selectedItem.IsOk()) {
        OnSelectionChanged(nullptr);
        event.Skip();
        return;
    }
 
    EmberCore::ITreeNode *node = GetNodeFromItem(selectedItem);
    if (node) {
        node->SetVisualState(EmberCore::ITreeNode::VisualState::Selected);
        if (m_config.syncSelectionWithCanvas) {
            ScrollToItemHorizontally(selectedItem);
        }
    }
    OnSelectionChanged(node);
    event.Skip();
}
 
void TreeHierarchyTab::OnTreeItemRightClick(wxTreeEvent &event) {
    EmberCore::ITreeNode *node = GetNodeFromItem(event.GetItem());
    if (!node)
        return;
 
    m_treeCtrl->SelectItem(event.GetItem());
 
    wxMenu contextMenu;
    OnPopulateContextMenu(node, contextMenu);
 
    if (contextMenu.GetMenuItemCount() > 0) {
        contextMenu.Bind(wxEVT_COMMAND_MENU_SELECTED,
                         [this, node](wxCommandEvent &cmd) { OnContextMenuCommand(cmd.GetId(), node); });
        PopupMenu(&contextMenu);
    }
}
 
void TreeHierarchyTab::OnTreeItemActivated(wxTreeEvent &event) {
    EmberCore::ITreeNode *node = GetNodeFromItem(event.GetItem());
    if (node) {
        OnNodeActivated(node);
    }
}
 
void TreeHierarchyTab::OnSearchTextChanged(wxCommandEvent &event) {
    if (m_config.liveSearch) {
        m_searchFilter = event.GetString();
        PopulateTree();
    }
}
 
void TreeHierarchyTab::OnSearchEnter(wxCommandEvent &event) {
    m_searchFilter = m_searchCtrl->GetValue();
    PopulateTree();
}
 
} // namespace EmberUI