NavigatorTab.cpp

Go to the documentation of this file.

#include "Tabs/NavigatorTab.h"
#include "Adapters/DirectTreeAdapter.h"
#include "Adapters/NodeAdapter.h"
#include "Core/BehaviorTree.h"
#include "Core/BlackboardEntry.h"
#include "Core/Node.h"
#include "Utils/Logger.h"
#include <algorithm>
#include <wx/dcbuffer.h>
#include <wx/menu.h>
 
namespace EmberUI {
 
static const int INDENT_PX = 18;
static const int CONNECTOR_X_OFFSET = 10;
static const int TOGGLE_SIZE = 10;
static const int BASE_LEFT_PAD = 10;
 
// ============================================================================
// NavigatorHierarchyView
// ============================================================================
 
NavigatorHierarchyView::NavigatorHierarchyView(wxWindow *parent, const EmberUI::TreeHierarchyConfig &config)
    : EmberUI::TreeHierarchyTab(parent, config) {}
 
void NavigatorHierarchyView::OnPopulateContextMenu(EmberCore::ITreeNode *node, wxMenu &menu) {
    if (m_contextPopulator)
        m_contextPopulator(node, menu);
}
 
void NavigatorHierarchyView::OnContextMenuCommand(int id, EmberCore::ITreeNode *node) {
    if (m_contextHandler)
        m_contextHandler(id, node);
}
 
void NavigatorHierarchyView::OnNodeActivated(EmberCore::ITreeNode *node) {
    if (m_activatedHandler)
        m_activatedHandler(node);
}
 
// ============================================================================
// NavigatorTreeListBox
// ============================================================================
 
NavigatorTreeListBox::NavigatorTreeListBox(NavigatorTab *owner, wxWindow *parent, wxWindowID id)
    : wxVListBox(parent, id, wxDefaultPosition, wxDefaultSize, wxBORDER_NONE), m_owner(owner) {
    SetBackgroundColour(wxColour(45, 45, 50));
    Bind(wxEVT_LEFT_DOWN, &NavigatorTreeListBox::OnLeftDown, this);
    Bind(wxEVT_LEFT_DCLICK, &NavigatorTreeListBox::OnLeftDClick, this);
    Bind(wxEVT_RIGHT_DOWN, &NavigatorTreeListBox::OnRightDown, this);
}
 
void NavigatorTreeListBox::OnDrawBackground(wxDC &dc, const wxRect &rect, size_t n) const {
    const auto &items = m_owner->GetFlatList();
    if (n >= items.size())
        return;
 
    const auto &entry = items[n];
 
    if (entry.isHeader) {
        dc.SetBrush(wxBrush(wxColour(38, 40, 45)));
        dc.SetPen(*wxTRANSPARENT_PEN);
        dc.DrawRectangle(rect);
        return;
    }
 
    bool isSelected = IsSelected(n);
    bool isCurrent = (entry.id == m_owner->GetCurrentTreeId());
    bool isBlackboard = (entry.section == NavigatorTab::SectionType::Blackboards);
 
    if (isSelected && isBlackboard) {
        dc.SetBrush(wxBrush(wxColour(70, 55, 100)));
    } else if (isSelected) {
        dc.SetBrush(wxBrush(wxColour(55, 75, 100)));
    } else if (isCurrent) {
        dc.SetBrush(wxBrush(wxColour(50, 60, 75)));
    } else if (n % 2 == 1) {
        dc.SetBrush(wxBrush(wxColour(48, 48, 53)));
    } else {
        dc.SetBrush(wxBrush(wxColour(45, 45, 50)));
    }
    dc.SetPen(*wxTRANSPARENT_PEN);
    dc.DrawRectangle(rect);
 
    if (isCurrent) {
        dc.SetBrush(wxBrush(wxColour(80, 160, 220)));
        dc.SetPen(*wxTRANSPARENT_PEN);
        dc.DrawRectangle(rect.x, rect.y + 4, 3, rect.height - 8);
    }
}
 
void NavigatorTreeListBox::OnDrawItem(wxDC &dc, const wxRect &rect, size_t n) const {
    const auto &items = m_owner->GetFlatList();
    if (n >= items.size())
        return;
 
    const auto &entry = items[n];
 
    if (entry.isHeader) {
        int leftPad = BASE_LEFT_PAD;
 
        int toggleX = leftPad;
        int toggleY = rect.y + (rect.height / 2) - (TOGGLE_SIZE / 2);
 
        dc.SetPen(wxPen(wxColour(180, 185, 195), 1));
        dc.SetBrush(wxBrush(wxColour(180, 185, 195)));
 
        if (entry.isCollapsed) {
            wxPoint tri[3] = {wxPoint(toggleX, toggleY), wxPoint(toggleX, toggleY + TOGGLE_SIZE),
                              wxPoint(toggleX + TOGGLE_SIZE - 2, toggleY + TOGGLE_SIZE / 2)};
            dc.DrawPolygon(3, tri);
        } else {
            wxPoint tri[3] = {wxPoint(toggleX, toggleY + 1), wxPoint(toggleX + TOGGLE_SIZE, toggleY + 1),
                              wxPoint(toggleX + TOGGLE_SIZE / 2, toggleY + TOGGLE_SIZE - 1)};
            dc.DrawPolygon(3, tri);
        }
        leftPad += TOGGLE_SIZE + 6;
 
        wxFont headerFont = GetFont();
        headerFont.SetPointSize(11);
        headerFont.SetWeight(wxFONTWEIGHT_BOLD);
        dc.SetFont(headerFont);
        dc.SetTextForeground(wxColour(200, 205, 215));
 
        wxString headerText = wxString::FromUTF8(entry.displayName);
        int textY = rect.y + (rect.height - dc.GetTextExtent(headerText).GetHeight()) / 2;
        dc.DrawText(headerText, rect.x + leftPad, textY);
 
        wxFont countFont = GetFont();
        countFont.SetPointSize(9);
        dc.SetFont(countFont);
        dc.SetTextForeground(wxColour(130, 135, 145));
 
        wxString countText = wxString::Format("(%d)", entry.sectionCount);
        int countW = dc.GetTextExtent(countText).GetWidth();
        int countX = rect.x + rect.width - countW - 10;
        dc.DrawText(countText, countX, textY + 1);
 
        dc.SetPen(wxPen(wxColour(60, 65, 75), 1));
        dc.DrawLine(rect.x + 4, rect.y + rect.height - 1, rect.x + rect.width - 4, rect.y + rect.height - 1);
 
        return;
    }
 
    bool isCurrent = (entry.id == m_owner->GetCurrentTreeId());
    int depth = entry.depth;
    int basePad = isCurrent ? BASE_LEFT_PAD + 4 : BASE_LEFT_PAD;
    int leftPad = basePad + depth * INDENT_PX;
 
    if (depth > 0) {
        wxPen connPen(wxColour(80, 85, 95), 1);
        dc.SetPen(connPen);
 
        for (int d = 1; d < depth; ++d) {
            if (d - 1 < static_cast<int>(entry.parentHasMore.size()) && entry.parentHasMore[d - 1]) {
                int lineX = basePad + d * INDENT_PX - CONNECTOR_X_OFFSET;
                dc.DrawLine(lineX, rect.y, lineX, rect.y + rect.height);
            }
        }
 
        int connX = leftPad - CONNECTOR_X_OFFSET;
        int midY = rect.y + rect.height / 2;
        dc.DrawLine(connX, rect.y, connX, entry.isLastChild ? midY : rect.y + rect.height);
        dc.DrawLine(connX, midY, connX + 8, midY);
    }
 
    if (entry.hasChildren) {
        int toggleX = leftPad;
        int toggleY = rect.y + (rect.height / 2) - (TOGGLE_SIZE / 2);
 
        dc.SetPen(wxPen(wxColour(150, 155, 165), 1));
 
        if (entry.isCollapsed) {
            wxPoint tri[3] = {wxPoint(toggleX, toggleY), wxPoint(toggleX, toggleY + TOGGLE_SIZE),
                              wxPoint(toggleX + TOGGLE_SIZE - 2, toggleY + TOGGLE_SIZE / 2)};
            dc.SetBrush(wxBrush(wxColour(150, 155, 165)));
            dc.DrawPolygon(3, tri);
        } else {
            wxPoint tri[3] = {wxPoint(toggleX, toggleY + 1), wxPoint(toggleX + TOGGLE_SIZE, toggleY + 1),
                              wxPoint(toggleX + TOGGLE_SIZE / 2, toggleY + TOGGLE_SIZE - 1)};
            dc.SetBrush(wxBrush(wxColour(150, 155, 165)));
            dc.DrawPolygon(3, tri);
        }
        leftPad += TOGGLE_SIZE + 4;
    } else {
        leftPad += 4;
    }
 
    wxFont nameFont = GetFont();
    nameFont.SetPointSize(10);
    if (isCurrent)
        nameFont.SetWeight(wxFONTWEIGHT_BOLD);
    dc.SetFont(nameFont);
 
    wxColour nameColour = isCurrent ? wxColour(230, 240, 255) : wxColour(210, 210, 215);
    if (!entry.isImplemented)
        nameColour = wxColour(140, 140, 155);
    if (entry.section == NavigatorTab::SectionType::Blackboards)
        nameColour = wxColour(180, 210, 255);
    dc.SetTextForeground(nameColour);
 
    wxString name = wxString::FromUTF8(entry.displayName);
    int nameY = rect.y + 7;
    dc.DrawText(name, rect.x + leftPad, nameY);
 
    wxFont subFont = GetFont();
    subFont.SetPointSize(8);
    dc.SetFont(subFont);
    dc.SetTextForeground(wxColour(110, 115, 125));
 
    wxString info;
    if (entry.section == NavigatorTab::SectionType::Blackboards) {
        info = wxString::Format("%d entr%s", entry.nodeCount, entry.nodeCount == 1 ? "y" : "ies");
    } else {
        if (entry.nodeCount > 0) {
            info = wxString::Format("%d node%s", entry.nodeCount, entry.nodeCount == 1 ? "" : "s");
        }
        if (!entry.isImplemented) {
            if (!info.IsEmpty())
                info += " - ";
            info += "unimplemented";
        }
        if (entry.section == NavigatorTab::SectionType::OtherTrees) {
            if (!info.IsEmpty())
                info += " - ";
            info += "not in main tree";
        } else if (entry.section == NavigatorTab::SectionType::MainTree && depth > 1) {
            if (!info.IsEmpty())
                info += " - ";
            info += "subtree";
        }
    }
 
    if (!info.IsEmpty()) {
        int infoY = nameY + dc.GetCharHeight() + 1;
        dc.DrawText(info, rect.x + leftPad, infoY);
    }
}
 
wxCoord NavigatorTreeListBox::OnMeasureItem(size_t n) const {
    const auto &items = m_owner->GetFlatList();
    if (n < items.size() && items[n].isHeader) {
        return 32;
    }
    return 44;
}
 
void NavigatorTreeListBox::OnLeftDown(wxMouseEvent &event) {
    int item = VirtualHitTest(event.GetPosition().y);
    if (item == wxNOT_FOUND) {
        event.Skip();
        return;
    }
 
    const auto &items = m_owner->GetFlatList();
    if (item < 0 || item >= static_cast<int>(items.size())) {
        event.Skip();
        return;
    }
 
    const auto &entry = items[item];
 
    if (entry.isHeader) {
        m_owner->ToggleSectionCollapse(entry.section);
        return;
    }
 
    if (entry.section == NavigatorTab::SectionType::Blackboards) {
        SetSelection(item);
        Refresh();
        m_owner->OnBlackboardClicked(entry.id);
        return;
    }
 
    if (entry.hasChildren) {
        bool isCurrent = (entry.id == m_owner->GetCurrentTreeId());
        int toggleHitX = m_owner->GetToggleHitX(entry.depth, isCurrent);
        int clickX = event.GetPosition().x;
 
        if (clickX >= toggleHitX && clickX < toggleHitX + TOGGLE_SIZE + 6) {
            m_owner->ToggleCollapse(entry.id);
            return;
        }
    }
 
    event.Skip();
}
 
void NavigatorTreeListBox::OnLeftDClick(wxMouseEvent &event) {
    int item = VirtualHitTest(event.GetPosition().y);
    if (item == wxNOT_FOUND)
        return;
 
    const auto &items = m_owner->GetFlatList();
    if (item < 0 || item >= static_cast<int>(items.size()))
        return;
 
    const auto &entry = items[item];
    if (entry.isHeader)
        return;
 
    if (entry.section == NavigatorTab::SectionType::Blackboards) {
        m_owner->OnBlackboardClicked(entry.id);
        return;
    }
 
    m_owner->DrillIntoTree(entry.id);
}
 
void NavigatorTreeListBox::OnRightDown(wxMouseEvent &event) {
    int item = VirtualHitTest(event.GetPosition().y);
    if (item == wxNOT_FOUND) {
        event.Skip();
        return;
    }
 
    const auto &items = m_owner->GetFlatList();
    if (item < 0 || item >= static_cast<int>(items.size())) {
        event.Skip();
        return;
    }
 
    if (items[item].isHeader || items[item].section == NavigatorTab::SectionType::Blackboards) {
        event.Skip();
        return;
    }
 
    SetSelection(item);
    Refresh();
    m_owner->ShowTreeContextMenu(item, event.GetPosition());
}
 
// ============================================================================
// SearchResultsListBox
// ============================================================================
 
SearchResultsListBox::SearchResultsListBox(NavigatorTab *owner, wxWindow *parent, wxWindowID id)
    : wxVListBox(parent, id, wxDefaultPosition, wxDefaultSize, wxBORDER_NONE), m_owner(owner) {
    SetBackgroundColour(wxColour(45, 45, 50));
    Bind(wxEVT_LEFT_DCLICK, &SearchResultsListBox::OnLeftDClick, this);
    Bind(wxEVT_RIGHT_DOWN, &SearchResultsListBox::OnRightDown, this);
}
 
void SearchResultsListBox::OnDrawBackground(wxDC &dc, const wxRect &rect, size_t n) const {
    bool isSelected = IsSelected(n);
    if (isSelected) {
        dc.SetBrush(wxBrush(wxColour(55, 75, 100)));
    } else if (n % 2 == 1) {
        dc.SetBrush(wxBrush(wxColour(48, 48, 53)));
    } else {
        dc.SetBrush(wxBrush(wxColour(45, 45, 50)));
    }
    dc.SetPen(*wxTRANSPARENT_PEN);
    dc.DrawRectangle(rect);
}
 
void SearchResultsListBox::OnDrawItem(wxDC &dc, const wxRect &rect, size_t n) const {
    const auto &results = m_owner->GetSearchResults();
    if (n >= results.size())
        return;
 
    const auto &result = results[n];
    int leftPad = BASE_LEFT_PAD;
 
    wxFont nameFont = GetFont();
    nameFont.SetPointSize(10);
    dc.SetFont(nameFont);
 
    if (result.type == NavigatorTab::SearchResult::Type::Tree) {
        dc.SetTextForeground(wxColour(100, 180, 255));
        wxString label = wxString::FromUTF8(result.treeId);
        int nameY = rect.y + 7;
        dc.DrawText(label, rect.x + leftPad, nameY);
 
        wxFont subFont = GetFont();
        subFont.SetPointSize(8);
        dc.SetFont(subFont);
        dc.SetTextForeground(wxColour(110, 115, 125));
        dc.DrawText("tree", rect.x + leftPad, nameY + dc.GetCharHeight() + 1);
    } else {
        dc.SetTextForeground(wxColour(210, 210, 215));
        wxString label = wxString::FromUTF8(result.nodeName);
        int nameY = rect.y + 7;
        dc.DrawText(label, rect.x + leftPad, nameY);
 
        wxFont subFont = GetFont();
        subFont.SetPointSize(8);
        dc.SetFont(subFont);
        dc.SetTextForeground(wxColour(110, 115, 125));
        wxString info = "in " + wxString::FromUTF8(result.treeId);
        dc.DrawText(info, rect.x + leftPad, nameY + dc.GetCharHeight() + 1);
    }
}
 
wxCoord SearchResultsListBox::OnMeasureItem(size_t) const { return 40; }
 
void SearchResultsListBox::OnLeftDClick(wxMouseEvent &event) {
    int item = VirtualHitTest(event.GetPosition().y);
    if (item == wxNOT_FOUND)
        return;
 
    const auto &results = m_owner->GetSearchResults();
    if (item < 0 || item >= static_cast<int>(results.size()))
        return;
 
    const auto &result = results[item];
    m_owner->ClearSearch();
    m_owner->DrillIntoTree(result.treeId);
 
    if (result.type == NavigatorTab::SearchResult::Type::Node) {
        m_owner->SelectNodeById(result.nodeId);
    }
}
 
void SearchResultsListBox::OnRightDown(wxMouseEvent &event) {
    int item = VirtualHitTest(event.GetPosition().y);
    if (item == wxNOT_FOUND)
        return;
 
    SetSelection(item);
    Refresh();
    m_owner->ShowSearchContextMenu(item, event.GetPosition());
}
 
// ============================================================================
// NavigatorTab
// ============================================================================
 
wxBEGIN_EVENT_TABLE(NavigatorTab, wxPanel) EVT_BUTTON(NavigatorTab::ID_BACK_BTN, NavigatorTab::OnBackClicked)
    EVT_MENU(NavigatorTab::ID_CTX_VIEW_CURRENT, NavigatorTab::OnTreeListContextViewInCurrent)
        EVT_MENU(NavigatorTab::ID_CTX_OPEN_NEW_SCENE, NavigatorTab::OnTreeListContextOpenNewScene)
            EVT_MENU(NavigatorTab::ID_CTX_BROWSE, NavigatorTab::OnTreeListContextBrowse)
                EVT_MENU(NavigatorTab::ID_CTX_EXPAND, NavigatorTab::OnTreeListContextExpand)
                    EVT_MENU(NavigatorTab::ID_CTX_COLLAPSE, NavigatorTab::OnTreeListContextCollapse) wxEND_EVENT_TABLE()
 
                        NavigatorTab::NavigatorTab(wxWindow *parent)
    : wxPanel(parent, wxID_ANY) {
    SetBackgroundColour(wxColour(45, 45, 50));
    InitLayout();
}
 
NavigatorTab::NavigatorTab(wxWindow *parent, bool deferLayout) : wxPanel(parent, wxID_ANY) {
    SetBackgroundColour(wxColour(45, 45, 50));
    if (!deferLayout)
        InitLayout();
}
 
NavigatorHierarchyView *NavigatorTab::CreateHierarchyView(wxWindow *parent, const TreeHierarchyConfig &cfg) {
    return new NavigatorHierarchyView(parent, cfg);
}
 
void NavigatorTab::InitLayout() {
    wxBoxSizer *mainSizer = new wxBoxSizer(wxVERTICAL);
 
    m_searchCtrl =
        new wxSearchCtrl(this, ID_SEARCH_CTRL, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_PROCESS_ENTER);
    m_searchCtrl->SetDescriptiveText("Search trees/nodes...");
    m_searchCtrl->ShowSearchButton(true);
    m_searchCtrl->ShowCancelButton(true);
    m_searchCtrl->Bind(wxEVT_TEXT, &NavigatorTab::OnSearchTextChanged, this);
    m_searchCtrl->Bind(wxEVT_SEARCHCTRL_SEARCH_BTN, &NavigatorTab::OnSearchEnter, this);
    m_searchCtrl->Bind(wxEVT_TEXT_ENTER, &NavigatorTab::OnSearchEnter, this);
    mainSizer->Add(m_searchCtrl, 0, wxEXPAND | wxALL, 4);
 
    m_breadcrumbPanel = new wxPanel(this, wxID_ANY);
    m_breadcrumbPanel->SetBackgroundColour(wxColour(50, 52, 58));
    wxBoxSizer *breadSizer = new wxBoxSizer(wxHORIZONTAL);
 
    m_backBtn = new wxButton(m_breadcrumbPanel, ID_BACK_BTN, wxString::FromUTF8("\xe2\x86\x90"), wxDefaultPosition,
                             wxDefaultSize, wxBU_EXACTFIT | wxBORDER_NONE);
    m_backBtn->SetBackgroundColour(wxColour(50, 52, 58));
    m_backBtn->SetForegroundColour(wxColour(140, 180, 220));
    m_backBtn->Hide();
 
    m_breadcrumbLabel = new wxStaticText(m_breadcrumbPanel, wxID_ANY, "Tree List");
    m_breadcrumbLabel->SetForegroundColour(wxColour(180, 185, 195));
    wxFont bcFont = m_breadcrumbLabel->GetFont();
    bcFont.SetPointSize(9);
    m_breadcrumbLabel->SetFont(bcFont);
 
    breadSizer->AddSpacer(6);
    breadSizer->Add(m_backBtn, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 4);
    breadSizer->Add(m_breadcrumbLabel, 1, wxALIGN_CENTER_VERTICAL);
    breadSizer->AddSpacer(6);
    m_breadcrumbPanel->SetSizer(breadSizer);
    mainSizer->Add(m_breadcrumbPanel, 0, wxEXPAND | wxLEFT | wxRIGHT, 2);
 
    m_book = new wxSimplebook(this, wxID_ANY);
 
    m_treeListBox = new NavigatorTreeListBox(this, m_book, ID_TREE_LIST);
    m_book->AddPage(m_treeListBox, "Tree List", true);
 
    EmberUI::TreeHierarchyConfig hierConfig;
    hierConfig.showSearchBar = false;
    hierConfig.autoExpandOnLoad = true;
    hierConfig.autoExpandDepth = 3;
    hierConfig.syncSelectionWithCanvas = true;
    hierConfig.panelColour = wxColour(45, 45, 50);
    hierConfig.backgroundColour = wxColour(50, 50, 50);
    m_hierarchyView = CreateHierarchyView(m_book, hierConfig);
    m_book->AddPage(m_hierarchyView, "Hierarchy", false);
 
    m_searchListBox = new SearchResultsListBox(this, m_book, ID_SEARCH_LIST);
    m_book->AddPage(m_searchListBox, "Search", false);
 
    mainSizer->Add(m_book, 1, wxEXPAND | wxLEFT | wxRIGHT, 2);
 
    m_statusLabel = new wxStaticText(this, wxID_ANY, "No project loaded");
    m_statusLabel->SetForegroundColour(wxColour(120, 125, 135));
    wxFont statusFont = m_statusLabel->GetFont();
    statusFont.SetPointSize(8);
    m_statusLabel->SetFont(statusFont);
    mainSizer->Add(m_statusLabel, 0, wxEXPAND | wxALL, 6);
 
    SetSizer(mainSizer);
 
    m_hierarchyView->SetSelectionCallback([this](EmberCore::ITreeNode *node) { OnHierarchySelectionChanged(node); });
    m_hierarchyView->SetContextMenuPopulator(
        [this](EmberCore::ITreeNode *node, wxMenu &menu) { OnHierarchyContextMenu(node, menu); });
    m_hierarchyView->SetContextMenuHandler(
        [this](int id, EmberCore::ITreeNode *node) { OnHierarchyContextCommand(id, node); });
    m_hierarchyView->SetNodeActivatedHandler([this](EmberCore::ITreeNode *node) { OnHierarchyNodeActivated(node); });
}
 
// --- Navigation ---
 
void NavigatorTab::DrillIntoTree(const std::string &treeId) {
    m_browsedTreeId = treeId;
 
    auto it = m_projectTrees.find(treeId);
    if (it != m_projectTrees.end() && it->second) {
        if (treeId == m_currentTreeId && m_activeTreeAdapter) {
            m_hierarchyView->SetTree(m_activeTreeAdapter);
        } else {
            auto adapter = std::make_shared<EmberCore::DirectTreeAdapter>(it->second);
            m_hierarchyView->SetTree(adapter);
        }
 
        EmberUI::TreeHierarchyConfig cfg = m_hierarchyView->GetConfig();
        cfg.syncSelectionWithCanvas = (treeId == m_currentTreeId);
        m_hierarchyView->ApplyConfig(cfg);
    } else if (treeId == m_currentTreeId && m_activeTreeAdapter) {
        m_hierarchyView->SetTree(m_activeTreeAdapter);
 
        EmberUI::TreeHierarchyConfig cfg = m_hierarchyView->GetConfig();
        cfg.syncSelectionWithCanvas = true;
        m_hierarchyView->ApplyConfig(cfg);
    }
 
    m_currentPage = ViewPage::Hierarchy;
    m_book->SetSelection(static_cast<int>(ViewPage::Hierarchy));
    m_hierarchyView->Layout();
    UpdateBreadcrumb();
    UpdateStatusLabel();
}
 
void NavigatorTab::NavigateBack() {
    m_browsedTreeId.clear();
    m_hierarchyView->ClearTree();
    m_currentPage = ViewPage::TreeList;
    m_book->SetSelection(static_cast<int>(ViewPage::TreeList));
    UpdateBreadcrumb();
    UpdateStatusLabel();
}
 
void NavigatorTab::UpdateBreadcrumb() {
    switch (m_currentPage) {
    case ViewPage::TreeList:
        m_backBtn->Hide();
        m_breadcrumbLabel->SetLabel("Tree List");
        break;
    case ViewPage::Hierarchy:
        m_backBtn->Show();
        m_breadcrumbLabel->SetLabel("Tree List / " + wxString::FromUTF8(m_browsedTreeId));
        break;
    case ViewPage::Search:
        m_backBtn->Show();
        m_breadcrumbLabel->SetLabel("Search: " + m_searchFilter);
        break;
    }
    m_breadcrumbPanel->Layout();
}
 
void NavigatorTab::UpdateStatusLabel() {
    if (m_projectTrees.empty()) {
        m_statusLabel->SetLabel("No project loaded");
        return;
    }
 
    if (m_currentPage == ViewPage::Hierarchy && !m_browsedTreeId.empty()) {
        auto it = m_treeInfoMap.find(m_browsedTreeId);
        int count = (it != m_treeInfoMap.end()) ? it->second.nodeCount : 0;
        wxString active = (m_browsedTreeId == m_currentTreeId) ? " (active)" : "";
        m_statusLabel->SetLabel(wxString::Format("%s: %d nodes%s", wxString::FromUTF8(m_browsedTreeId), count, active));
    } else if (m_currentPage == ViewPage::Search) {
        m_statusLabel->SetLabel(wxString::Format("%zu results", m_searchResults.size()));
    } else {
        m_statusLabel->SetLabel(
            wxString::Format("%zu tree%s", m_treeInfoMap.size(), m_treeInfoMap.size() == 1 ? "" : "s"));
    }
}
 
// --- Tree list management ---
 
void NavigatorTab::UpdateTreeList(const std::map<std::string, std::shared_ptr<EmberCore::BehaviorTree>> &trees,
                                  const std::string &currentTreeId) {
    m_projectTrees = trees;
    m_currentTreeId = currentTreeId;
    m_treeInfoMap.clear();
 
    for (const auto &pair : trees) {
        TreeInfo info;
        info.id = pair.first;
        info.nodeCount = pair.second ? static_cast<int>(pair.second->GetNodeCount()) : 0;
        info.isImplemented = pair.second && pair.second->HasRootNode() && pair.second->GetNodeCount() > 0;
 
        if (pair.second && pair.second->GetRootNode()) {
            CollectSubTreeRefs(pair.second->GetRootNode(), info.subtreeRefs);
        }
 
        m_treeInfoMap[pair.first] = std::move(info);
    }
 
    m_collapsedTrees.clear();
    for (const auto &pair : m_treeInfoMap) {
        if (!pair.second.subtreeRefs.empty()) {
            m_collapsedTrees.insert(pair.first);
        }
    }
 
    BuildFlatList();
    UpdateStatusLabel();
}
 
void NavigatorTab::SetCurrentTree(const std::string &treeId) {
    m_currentTreeId = treeId;
    BuildFlatList();
    UpdateStatusLabel();
}
 
void NavigatorTab::ClearTreeList() {
    m_projectTrees.clear();
    m_treeInfoMap.clear();
    m_flatList.clear();
    m_collapsedTrees.clear();
    m_mainTreeSectionCollapsed = false;
    m_otherTreesSectionCollapsed = false;
    m_blackboardsSectionCollapsed = false;
    m_blackboards.clear();
    m_currentTreeId.clear();
    m_mainTreeId.clear();
    m_browsedTreeId.clear();
    m_activeTreeAdapter.reset();
    m_searchResults.clear();
    m_treeListBox->SetItemCount(0);
    m_treeListBox->Refresh();
    m_searchListBox->SetItemCount(0);
    m_searchListBox->Refresh();
    m_hierarchyView->ClearTree();
 
    if (m_currentPage != ViewPage::TreeList) {
        m_currentPage = ViewPage::TreeList;
        m_book->SetSelection(0);
        UpdateBreadcrumb();
    }
    UpdateStatusLabel();
}
 
// --- Active tree (shared with canvas) ---
 
void NavigatorTab::SetActiveTree(std::shared_ptr<EmberCore::ITreeStructure> tree, const std::string &treeId) {
    m_activeTreeAdapter = tree;
    m_currentTreeId = treeId;
 
    if (m_currentPage == ViewPage::Hierarchy && m_browsedTreeId == treeId && m_activeTreeAdapter) {
        m_hierarchyView->SetTree(m_activeTreeAdapter);
        EmberUI::TreeHierarchyConfig cfg = m_hierarchyView->GetConfig();
        cfg.syncSelectionWithCanvas = true;
        m_hierarchyView->ApplyConfig(cfg);
    }
 
    BuildFlatList();
    UpdateStatusLabel();
}
 
void NavigatorTab::SelectNodeById(size_t nodeId) {
    if (m_currentPage == ViewPage::Hierarchy) {
        m_hierarchyView->SelectNodeById(nodeId);
    }
}
 
void NavigatorTab::RefreshHierarchy() {
    if (m_currentPage == ViewPage::Hierarchy) {
        m_hierarchyView->RefreshTree();
    }
}
 
void NavigatorTab::SetLayoutInvalidationCallback(std::function<void()> cb) {
    m_hierarchyView->SetLayoutInvalidationCallback(cb);
}
 
void NavigatorTab::SetNodeSelectionCallback(std::function<void(EmberCore::ITreeNode *)> cb) {
    m_nodeSelectionCallback = std::move(cb);
}
 
void NavigatorTab::SetMainTreeId(const std::string &id) {
    m_mainTreeId = id;
    LOG_INFO("Navigator", "SetMainTreeId called with: '" + id + "'");
}
 
void NavigatorTab::SetBlackboards(const std::map<std::string, std::shared_ptr<EmberCore::Blackboard>> &bbs) {
    m_blackboards = bbs;
    BuildFlatList();
}
 
void NavigatorTab::SetBlackboardSelectionCallback(std::function<void(const std::string &)> cb) {
    m_blackboardSelectionCallback = std::move(cb);
}
 
void NavigatorTab::OnBlackboardClicked(const std::string &bbId) {
    if (m_blackboardSelectionCallback) {
        m_blackboardSelectionCallback(bbId);
    }
}
 
// --- Tree list building ---
 
void NavigatorTab::CollectSubTreeRefs(EmberCore::Node *node, std::set<std::string> &refs) const {
    if (!node)
        return;
 
    std::string subtreeRef = node->GetAttribute("__subtree_ref__", "");
    if (!subtreeRef.empty()) {
        refs.insert(subtreeRef);
    }
 
    for (size_t i = 0; i < node->GetChildCount(); ++i) {
        CollectSubTreeRefs(node->GetChild(i), refs);
    }
}
 
void NavigatorTab::CollectAllReachableSubtrees(const std::string &treeId, std::set<std::string> &reachable) const {
    auto it = m_treeInfoMap.find(treeId);
    if (it == m_treeInfoMap.end())
        return;
 
    for (const auto &ref : it->second.subtreeRefs) {
        if (reachable.insert(ref).second) {
            CollectAllReachableSubtrees(ref, reachable);
        }
    }
}
 
void NavigatorTab::BuildFlatList() {
    m_flatList.clear();
 
    if (m_treeInfoMap.empty() && m_blackboards.empty()) {
        m_treeListBox->SetItemCount(0);
        m_treeListBox->Refresh();
        return;
    }
 
    std::set<std::string> mainTreeRefs;
    bool hasMainTree = !m_mainTreeId.empty() && m_treeInfoMap.count(m_mainTreeId);
 
    LOG_INFO("Navigator", "BuildFlatList: m_mainTreeId='" + m_mainTreeId +
                              "' hasMainTree=" + (hasMainTree ? "true" : "false") +
                              " treeInfoMap.size()=" + std::to_string(m_treeInfoMap.size()));
 
    if (hasMainTree) {
        CollectAllReachableSubtrees(m_mainTreeId, mainTreeRefs);
        LOG_INFO("Navigator", "BuildFlatList: mainTreeRefs.size()=" + std::to_string(mainTreeRefs.size()));
    }
 
    std::vector<std::string> otherTrees;
    for (const auto &pair : m_treeInfoMap) {
        if (hasMainTree && (pair.first == m_mainTreeId || mainTreeRefs.count(pair.first)))
            continue;
        otherTrees.push_back(pair.first);
    }
    std::sort(otherTrees.begin(), otherTrees.end());
 
    if (hasMainTree) {
        FlatEntry header;
        header.id = "__section_main_tree__";
        header.displayName = "Main Tree";
        header.nodeCount = 0;
        header.depth = 0;
        header.isImplemented = true;
        header.isLastChild = otherTrees.empty() && m_blackboards.empty();
        header.hasChildren = true;
        header.isCollapsed = m_mainTreeSectionCollapsed;
        header.isHeader = true;
        header.section = SectionType::MainTree;
        header.sectionCount = 1 + static_cast<int>(mainTreeRefs.size());
        m_flatList.push_back(std::move(header));
 
        if (!m_mainTreeSectionCollapsed) {
            std::set<std::string> visited;
            FlattenTree(m_mainTreeId, 1, visited, true, {});
        }
    }
 
    if (!otherTrees.empty()) {
        FlatEntry header;
        header.id = "__section_other__";
        header.displayName = "Other Trees";
        header.nodeCount = 0;
        header.depth = 0;
        header.isImplemented = true;
        header.isLastChild = m_blackboards.empty();
        header.hasChildren = true;
        header.isCollapsed = m_otherTreesSectionCollapsed;
        header.isHeader = true;
        header.section = SectionType::OtherTrees;
        header.sectionCount = static_cast<int>(otherTrees.size());
        m_flatList.push_back(std::move(header));
 
        if (!m_otherTreesSectionCollapsed) {
            for (size_t i = 0; i < otherTrees.size(); ++i) {
                const auto &id = otherTrees[i];
                const auto &info = m_treeInfoMap[id];
                FlatEntry e;
                e.id = info.id;
                e.displayName = info.id;
                e.nodeCount = info.nodeCount;
                e.depth = 1;
                e.isImplemented = info.isImplemented;
                e.isLastChild = (i == otherTrees.size() - 1);
                e.hasChildren = false;
                e.isCollapsed = false;
                e.isHeader = false;
                e.section = SectionType::OtherTrees;
                e.sectionCount = 0;
                m_flatList.push_back(std::move(e));
            }
        }
    }
 
    if (!m_blackboards.empty()) {
        FlatEntry header;
        header.id = "__section_blackboards__";
        header.displayName = "Blackboards";
        header.nodeCount = 0;
        header.depth = 0;
        header.isImplemented = true;
        header.isLastChild = true;
        header.hasChildren = true;
        header.isCollapsed = m_blackboardsSectionCollapsed;
        header.isHeader = true;
        header.section = SectionType::Blackboards;
        header.sectionCount = static_cast<int>(m_blackboards.size());
        m_flatList.push_back(std::move(header));
 
        if (!m_blackboardsSectionCollapsed) {
            std::vector<std::string> bbIds;
            bbIds.reserve(m_blackboards.size());
            for (const auto &kv : m_blackboards) {
                bbIds.push_back(kv.first);
            }
            std::sort(bbIds.begin(), bbIds.end());
 
            for (size_t i = 0; i < bbIds.size(); ++i) {
                const auto &id = bbIds[i];
                const auto &bb = m_blackboards.at(id);
                FlatEntry e;
                e.id = id;
                e.displayName = id;
                e.nodeCount = bb ? static_cast<int>(bb->GetEntryCount()) : 0;
                e.depth = 1;
                e.isImplemented = true;
                e.isLastChild = (i == bbIds.size() - 1);
                e.hasChildren = false;
                e.isCollapsed = false;
                e.isHeader = false;
                e.section = SectionType::Blackboards;
                e.sectionCount = 0;
                m_flatList.push_back(std::move(e));
            }
        }
    }
 
    m_treeListBox->SetItemCount(m_flatList.size());
 
    int idx = FindItemByTreeId(m_currentTreeId);
    if (idx >= 0) {
        m_treeListBox->SetSelection(idx);
    } else {
        m_treeListBox->SetSelection(wxNOT_FOUND);
    }
 
    m_treeListBox->Refresh();
}
 
void NavigatorTab::FlattenTree(const std::string &treeId, int depth, std::set<std::string> &visited, bool isLastChild,
                               std::vector<bool> parentHasMore) {
    if (depth > 20)
        return;
 
    auto it = m_treeInfoMap.find(treeId);
    if (it == m_treeInfoMap.end())
        return;
 
    bool isCircular = visited.find(treeId) != visited.end();
    visited.insert(treeId);
 
    const TreeInfo &info = it->second;
    bool hasKids = !isCircular && !info.subtreeRefs.empty();
    bool collapsed = hasKids && IsCollapsed(treeId);
 
    FlatEntry e;
    e.id = info.id;
    e.displayName = info.id;
    e.nodeCount = info.nodeCount;
    e.depth = depth;
    e.isImplemented = info.isImplemented;
    e.isLastChild = isLastChild;
    e.hasChildren = hasKids;
    e.isCollapsed = collapsed;
    e.isHeader = false;
    e.section = SectionType::MainTree;
    e.sectionCount = 0;
    e.parentHasMore = parentHasMore;
 
    m_flatList.push_back(std::move(e));
 
    if (hasKids && !collapsed) {
        std::vector<std::string> sortedRefs(info.subtreeRefs.begin(), info.subtreeRefs.end());
        std::sort(sortedRefs.begin(), sortedRefs.end());
 
        std::vector<bool> childParentHasMore = parentHasMore;
        childParentHasMore.push_back(!isLastChild);
 
        for (size_t i = 0; i < sortedRefs.size(); ++i) {
            bool childIsLast = (i == sortedRefs.size() - 1);
            FlattenTree(sortedRefs[i], depth + 1, visited, childIsLast, childParentHasMore);
        }
    }
 
    visited.erase(treeId);
}
 
int NavigatorTab::FindItemByTreeId(const std::string &treeId) const {
    for (size_t i = 0; i < m_flatList.size(); ++i) {
        if (m_flatList[i].id == treeId) {
            return static_cast<int>(i);
        }
    }
    return -1;
}
 
void NavigatorTab::ToggleCollapse(const std::string &treeId) {
    size_t firstVisible = m_treeListBox->GetVisibleRowsBegin();
    auto it = m_collapsedTrees.find(treeId);
    if (it != m_collapsedTrees.end()) {
        m_collapsedTrees.erase(it);
    } else {
        m_collapsedTrees.insert(treeId);
    }
    BuildFlatList();
    if (firstVisible < m_treeListBox->GetItemCount()) {
        m_treeListBox->ScrollToRow(firstVisible);
    }
}
 
bool NavigatorTab::IsCollapsed(const std::string &treeId) const {
    return m_collapsedTrees.find(treeId) != m_collapsedTrees.end();
}
 
void NavigatorTab::ToggleSectionCollapse(SectionType section) {
    size_t firstVisible = m_treeListBox->GetVisibleRowsBegin();
    if (section == SectionType::MainTree) {
        m_mainTreeSectionCollapsed = !m_mainTreeSectionCollapsed;
    } else if (section == SectionType::OtherTrees) {
        m_otherTreesSectionCollapsed = !m_otherTreesSectionCollapsed;
    } else if (section == SectionType::Blackboards) {
        m_blackboardsSectionCollapsed = !m_blackboardsSectionCollapsed;
    }
    BuildFlatList();
    if (firstVisible < m_treeListBox->GetItemCount()) {
        m_treeListBox->ScrollToRow(firstVisible);
    }
}
 
bool NavigatorTab::IsSectionCollapsed(SectionType section) const {
    if (section == SectionType::MainTree)
        return m_mainTreeSectionCollapsed;
    if (section == SectionType::OtherTrees)
        return m_otherTreesSectionCollapsed;
    if (section == SectionType::Blackboards)
        return m_blackboardsSectionCollapsed;
    return false;
}
 
int NavigatorTab::GetToggleHitX(int depth, bool isCurrent) const {
    int basePad = isCurrent ? BASE_LEFT_PAD + 4 : BASE_LEFT_PAD;
    return basePad + depth * INDENT_PX;
}
 
void NavigatorTab::CollapseAllTrees() {
    m_collapsedTrees.clear();
    for (const auto &pair : m_treeInfoMap) {
        if (!pair.second.subtreeRefs.empty()) {
            m_collapsedTrees.insert(pair.first);
        }
    }
    BuildFlatList();
}
 
void NavigatorTab::ExpandAllTrees() {
    m_collapsedTrees.clear();
    BuildFlatList();
}
 
void NavigatorTab::ClearSearch() {
    if (m_currentPage != ViewPage::Search)
        return;
    m_searchCtrl->ChangeValue("");
    m_searchFilter.Clear();
    m_searchResults.clear();
    m_searchListBox->SetItemCount(0);
    m_searchListBox->Refresh();
}
 
// --- Global search ---
 
void NavigatorTab::PerformGlobalSearch(const wxString &query) {
    m_searchResults.clear();
    wxString lower = query.Lower();
 
    for (const auto &pair : m_treeInfoMap) {
        wxString treeIdLower = wxString::FromUTF8(pair.first).Lower();
        if (treeIdLower.Find(lower) != wxNOT_FOUND) {
            SearchResult r;
            r.type = SearchResult::Type::Tree;
            r.treeId = pair.first;
            r.nodeId = 0;
            m_searchResults.push_back(r);
        }
    }
 
    static const size_t MAX_NODE_RESULTS = 200;
    size_t nodeResults = 0;
    for (const auto &pair : m_projectTrees) {
        if (!pair.second || !pair.second->HasRootNode() || nodeResults >= MAX_NODE_RESULTS)
            continue;
 
        auto adapter = std::make_shared<EmberCore::DirectTreeAdapter>(pair.second);
        bool limitReached = false;
        adapter->TraverseNodes([&](EmberCore::ITreeNode *node) {
            if (limitReached)
                return;
            wxString nameLower = wxString(node->GetName().c_str()).Lower();
            if (nameLower.Find(lower) != wxNOT_FOUND) {
                SearchResult r;
                r.type = SearchResult::Type::Node;
                r.treeId = pair.first;
                r.nodeName = node->GetName();
                r.nodeId = node->GetId();
                m_searchResults.push_back(r);
                ++nodeResults;
                if (nodeResults >= MAX_NODE_RESULTS)
                    limitReached = true;
            }
        });
    }
 
    m_searchListBox->SetItemCount(m_searchResults.size());
    m_searchListBox->Refresh();
}
 
// --- Hierarchy hooks ---
 
void NavigatorTab::OnHierarchySelectionChanged(EmberCore::ITreeNode *node) {
    if (!m_browsedTreeId.empty() && m_browsedTreeId == m_currentTreeId && m_nodeSelectionCallback) {
        m_nodeSelectionCallback(node);
    }
}
 
void NavigatorTab::OnHierarchyContextMenu(EmberCore::ITreeNode *node, wxMenu &menu) {
    if (!node)
        return;
 
    bool isActive = (!m_browsedTreeId.empty() && m_browsedTreeId == m_currentTreeId);
 
    if (isActive && m_editingEnabled) {
        menu.Append(ID_CTX_ADD_CHILD, "Add Child Node");
        menu.AppendSeparator();
        menu.Append(ID_CTX_RENAME_NODE, "Rename");
        menu.Append(ID_CTX_DUPLICATE_NODE, "Duplicate");
        menu.AppendSeparator();
        menu.Append(ID_CTX_DELETE_NODE, "Delete");
    } else {
        bool canView = m_callbacks.canViewInCurrentScene ? m_callbacks.canViewInCurrentScene() : false;
        menu.Append(ID_CTX_OPEN_TREE, "Open this tree in current scene");
        menu.Enable(ID_CTX_OPEN_TREE, canView);
    }
}
 
void NavigatorTab::OnHierarchyContextCommand(int id, EmberCore::ITreeNode *node) {
    if (id == ID_CTX_OPEN_TREE && !m_browsedTreeId.empty()) {
        if (m_treeSelectionCallback) {
            m_treeSelectionCallback(m_browsedTreeId);
        }
        return;
    }
 
    EmberCore::Node *mutableNode = GetMutableNode(node);
    if (!mutableNode)
        return;
 
    switch (id) {
    case ID_CTX_ADD_CHILD: {
        auto newNode = EmberCore::NodeFactory::CreateActionNode("New Action");
        mutableNode->AddChild(std::move(newNode));
        RefreshHierarchy();
        if (m_callbacks.refreshVisualization)
            m_callbacks.refreshVisualization();
        break;
    }
    case ID_CTX_DELETE_NODE: {
        if (!mutableNode->GetParent())
            break;
        int result = wxMessageBox(wxString::Format("Delete '%s' and all its children?", mutableNode->GetName()),
                                  "Confirm Delete", wxYES_NO | wxICON_QUESTION, this);
        if (result == wxYES) {
            EmberCore::Node *parent = mutableNode->GetParent();
            if (parent) {
                parent->RemoveChild(mutableNode);
            }
            CallAfter([this]() {
                RefreshHierarchy();
                if (m_callbacks.refreshVisualization)
                    m_callbacks.refreshVisualization();
            });
        }
        break;
    }
    case ID_CTX_RENAME_NODE: {
        wxString currentName = mutableNode->GetName();
        wxString newName = wxGetTextFromUser("Enter new name:", "Rename Node", currentName, this);
        if (!newName.IsEmpty() && newName != currentName) {
            mutableNode->SetName(newName.ToStdString());
            CallAfter([this]() {
                RefreshHierarchy();
                if (m_callbacks.refreshVisualization)
                    m_callbacks.refreshVisualization();
            });
        }
        break;
    }
    case ID_CTX_DUPLICATE_NODE: {
        if (!mutableNode->GetParent())
            break;
        auto dup = mutableNode->DeepCopy();
        dup->SetName(mutableNode->GetName() + " Copy");
        mutableNode->GetParent()->AddChild(std::move(dup));
        wxTheApp->CallAfter([this]() {
            RefreshHierarchy();
            if (m_callbacks.refreshVisualization)
                m_callbacks.refreshVisualization();
        });
        break;
    }
    }
}
 
void NavigatorTab::OnHierarchyNodeActivated(EmberCore::ITreeNode *node) {
    if (!node)
        return;
 
    if (m_browsedTreeId == m_currentTreeId && m_callbacks.centerOnNode) {
        m_callbacks.centerOnNode(node);
    }
}
 
EmberCore::Node *NavigatorTab::GetMutableNode(EmberCore::ITreeNode *inode) const {
    if (!inode)
        return nullptr;
    auto *adapter = dynamic_cast<EmberCore::NodeAdapter *>(inode);
    if (adapter)
        return adapter->GetWrappedNode();
    return nullptr;
}
 
// --- Tree list context menu ---
 
void NavigatorTab::ShowTreeContextMenu(int itemIndex, const wxPoint &pos) {
    if (itemIndex < 0 || itemIndex >= static_cast<int>(m_flatList.size()))
        return;
 
    m_contextMenuTreeId = m_flatList[itemIndex].id;
 
    bool canViewInCurrent = m_callbacks.canViewInCurrentScene ? m_callbacks.canViewInCurrentScene() : false;
 
    wxMenu menu;
    menu.Append(ID_CTX_VIEW_CURRENT, "View in Current Scene");
    menu.Enable(ID_CTX_VIEW_CURRENT, canViewInCurrent);
    menu.Append(ID_CTX_OPEN_NEW_SCENE, "Open in New Scene");
    menu.Append(ID_CTX_BROWSE, "Browse Hierarchy");
    menu.AppendSeparator();
 
    const auto &entry = m_flatList[itemIndex];
    if (entry.hasChildren) {
        if (entry.isCollapsed)
            menu.Append(ID_CTX_EXPAND, "Expand");
        else
            menu.Append(ID_CTX_COLLAPSE, "Collapse");
    }
 
    m_treeListBox->PopupMenu(&menu, pos);
}
 
void NavigatorTab::ShowSearchContextMenu(int resultIndex, const wxPoint &pos) {
    const auto &results = m_searchResults;
    if (resultIndex < 0 || resultIndex >= static_cast<int>(results.size()))
        return;
 
    const auto &result = results[resultIndex];
    m_contextMenuTreeId = result.treeId;
 
    bool canViewInCurrent = m_callbacks.canViewInCurrentScene ? m_callbacks.canViewInCurrentScene() : false;
 
    wxMenu menu;
    menu.Append(ID_CTX_VIEW_CURRENT, "View in Current Scene");
    menu.Enable(ID_CTX_VIEW_CURRENT, canViewInCurrent);
    menu.Append(ID_CTX_OPEN_NEW_SCENE, "Open in New Scene");
    menu.Append(ID_CTX_BROWSE, "Browse Hierarchy");
 
    m_searchListBox->PopupMenu(&menu, pos);
}
 
void NavigatorTab::OnTreeListContextViewInCurrent(wxCommandEvent &) {
    if (m_contextMenuTreeId.empty())
        return;
    ClearSearch();
    if (m_contextMenuTreeId != m_currentTreeId && m_treeSelectionCallback) {
        m_treeSelectionCallback(m_contextMenuTreeId);
    }
}
 
void NavigatorTab::OnTreeListContextOpenNewScene(wxCommandEvent &) {
    if (m_contextMenuTreeId.empty())
        return;
    ClearSearch();
    if (m_callbacks.openInNewScene)
        m_callbacks.openInNewScene(m_contextMenuTreeId);
}
 
void NavigatorTab::OnTreeListContextBrowse(wxCommandEvent &) {
    if (!m_contextMenuTreeId.empty()) {
        ClearSearch();
        DrillIntoTree(m_contextMenuTreeId);
    }
}
 
void NavigatorTab::OnTreeListContextExpand(wxCommandEvent &) {
    if (!m_contextMenuTreeId.empty() && IsCollapsed(m_contextMenuTreeId))
        ToggleCollapse(m_contextMenuTreeId);
}
 
void NavigatorTab::OnTreeListContextCollapse(wxCommandEvent &) {
    if (!m_contextMenuTreeId.empty() && !IsCollapsed(m_contextMenuTreeId))
        ToggleCollapse(m_contextMenuTreeId);
}
 
// --- Search ---
 
void NavigatorTab::OnSearchTextChanged(wxCommandEvent &) {
    m_searchFilter = m_searchCtrl->GetValue();
 
    if (m_searchFilter.IsEmpty()) {
        if (m_currentPage == ViewPage::Search) {
            m_currentPage = m_pageBeforeSearch;
            m_book->SetSelection(static_cast<int>(m_currentPage));
            UpdateBreadcrumb();
            UpdateStatusLabel();
        }
        return;
    }
 
    if (m_currentPage != ViewPage::Search) {
        m_pageBeforeSearch = m_currentPage;
    }
 
    PerformGlobalSearch(m_searchFilter);
    m_currentPage = ViewPage::Search;
    m_book->SetSelection(static_cast<int>(ViewPage::Search));
    UpdateBreadcrumb();
    UpdateStatusLabel();
 
    m_searchCtrl->SetFocus();
}
 
void NavigatorTab::OnSearchEnter(wxCommandEvent &) {
    m_searchFilter = m_searchCtrl->GetValue();
    if (!m_searchFilter.IsEmpty()) {
        if (m_currentPage != ViewPage::Search) {
            m_pageBeforeSearch = m_currentPage;
        }
        PerformGlobalSearch(m_searchFilter);
        m_currentPage = ViewPage::Search;
        m_book->SetSelection(static_cast<int>(ViewPage::Search));
        UpdateBreadcrumb();
        UpdateStatusLabel();
    }
}
 
// --- Breadcrumb ---
 
void NavigatorTab::OnBackClicked(wxCommandEvent &) {
    if (m_currentPage == ViewPage::Search) {
        m_searchCtrl->ChangeValue("");
        m_searchFilter.Clear();
        m_currentPage = m_pageBeforeSearch;
        m_book->SetSelection(static_cast<int>(m_currentPage));
        UpdateBreadcrumb();
        UpdateStatusLabel();
    } else if (m_currentPage == ViewPage::Hierarchy) {
        NavigateBack();
    }
}
 
// --- ITab lifecycle ---
 
void NavigatorTab::OnClosed() {
    if (m_callbacks.onTabClosed)
        m_callbacks.onTabClosed();
}
 
void NavigatorTab::OnActivated() {
    if (!m_currentTreeId.empty() && m_currentPage == ViewPage::TreeList) {
        int idx = FindItemByTreeId(m_currentTreeId);
        if (idx >= 0) {
            m_treeListBox->SetSelection(idx);
            m_treeListBox->Refresh();
        }
    }
}
 
} // namespace EmberUI