TreeCanvas.cpp

Go to the documentation of this file.

#include "Visualization/TreeCanvas.h"
#include <algorithm>
#include <cmath>
#include <wx/filename.h>
 
namespace EmberUI {
 
wxBEGIN_EVENT_TABLE(TreeCanvas, wxPanel) EVT_PAINT(TreeCanvas::OnPaint) EVT_SIZE(TreeCanvas::OnSize)
    EVT_LEFT_DOWN(TreeCanvas::OnMouseLeftDown) EVT_LEFT_UP(TreeCanvas::OnMouseLeftUp)
        EVT_LEFT_DCLICK(TreeCanvas::OnMouseLeftDClick) EVT_MOTION(TreeCanvas::OnMouseMotion)
            EVT_MOUSEWHEEL(TreeCanvas::OnMouseWheel) EVT_MIDDLE_DOWN(TreeCanvas::OnMouseMiddleDown)
                EVT_MIDDLE_UP(TreeCanvas::OnMouseMiddleUp) EVT_RIGHT_UP(TreeCanvas::OnMouseRightUp) wxEND_EVENT_TABLE()
 
                    TreeCanvas::TreeCanvas(wxWindow *parent, wxWindowID id)
    : wxPanel(parent, id), m_titleFont(12, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL),
      m_typeFont(9, wxFONTFAMILY_SWISS, wxFONTSTYLE_ITALIC, wxFONTWEIGHT_NORMAL),
      m_headerFont(8, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD) {
    SetBackgroundStyle(wxBG_STYLE_PAINT);
    SetBackgroundColour(m_config.background_color);
    SetCanFocus(true);
    UpdateScaledConfig();
 
    Bind(wxEVT_KEY_DOWN, [this](wxKeyEvent &e) { OnKeyDown(e); });
    Bind(wxEVT_KEY_UP, [this](wxKeyEvent &e) { OnKeyUp(e); });
 
    m_lastFrameTime = wxGetUTCTimeMillis();
 
    m_refreshTimer = new wxTimer(this, wxID_ANY);
    m_refreshTimer->Start(16);
 
    Bind(wxEVT_TIMER, [this](wxTimerEvent &) {
        wxLongLong currentTime = wxGetUTCTimeMillis();
        double deltaTime = (currentTime - m_lastFrameTime).ToDouble() / 1000.0;
        m_lastFrameTime = currentTime;
 
        if (deltaTime > 0.1)
            deltaTime = 0.033;
 
        if (m_config.enable_smooth_panning) {
            float dx = static_cast<float>(m_targetOffset.x - m_viewOffset.x);
            float dy = static_cast<float>(m_targetOffset.y - m_viewOffset.y);
 
            if (std::abs(dx) > 0.5f || std::abs(dy) > 0.5f) {
                float speed = std::max(5.0f, 100.0f - m_config.pan_smoothness);
                float alpha = 1.0f - std::exp(-speed * static_cast<float>(deltaTime));
                int stepX = static_cast<int>(dx * alpha);
                int stepY = static_cast<int>(dy * alpha);
                if (stepX == 0 && dx != 0.0f)
                    stepX = dx > 0 ? 1 : -1;
                if (stepY == 0 && dy != 0.0f)
                    stepY = dy > 0 ? 1 : -1;
                m_viewOffset.x += stepX;
                m_viewOffset.y += stepY;
                m_dirty = true;
            } else {
                m_viewOffset = m_targetOffset;
            }
        } else {
            m_viewOffset = m_targetOffset;
        }
 
        if (m_dirty) {
            m_dirty = false;
            Refresh();
        }
    });
}
 
TreeCanvas::~TreeCanvas() {
    if (m_refreshTimer) {
        m_refreshTimer->Stop();
        delete m_refreshTimer;
        m_refreshTimer = nullptr;
    }
}
 
void TreeCanvas::LoadTypeIcons() {
    if (m_config.icon_directory.empty())
        return;
 
    wxString dir = m_config.icon_directory;
    if (!dir.EndsWith("/") && !dir.EndsWith("\\"))
        dir += "/";
 
    struct IconEntry {
        EmberCore::ITreeNode::NodeType type;
        wxString filename;
    };
 
    IconEntry entries[] = {
        {EmberCore::ITreeNode::NodeType::Action, "action_node_20.png"},
        {EmberCore::ITreeNode::NodeType::Control, "control_node_20.png"},
        {EmberCore::ITreeNode::NodeType::Condition, "condition_node_20.png"},
        {EmberCore::ITreeNode::NodeType::Decorator, "decorator_node_20.png"},
        {EmberCore::ITreeNode::NodeType::BehaviorTree, "tree_node_20.png"},
    };
 
    int iconSize = std::max(8, m_scaled.type_header_height - 4);
 
    for (const auto &entry : entries) {
        wxString path = dir + entry.filename;
        if (wxFileName::Exists(path)) {
            wxImage img(path, wxBITMAP_TYPE_PNG);
            if (img.IsOk()) {
                if (img.GetWidth() != iconSize || img.GetHeight() != iconSize) {
                    img = img.Scale(iconSize, iconSize, wxIMAGE_QUALITY_BICUBIC);
                }
                m_typeIcons[entry.type] = wxBitmap(img);
            }
        }
    }
}
 
void TreeCanvas::AutoCollapseTree(EmberCore::ITreeNode *node, int depth) {
    if (!node)
        return;
 
    if (depth >= m_config.autoCollapseDepth && node->GetChildCount() > 0) {
        node->SetChildrenVisible(false);
        return;
    }
 
    for (size_t i = 0; i < node->GetChildCount(); ++i) {
        EmberCore::ITreeNode *child = node->GetChild(i);
        if (child) {
            AutoCollapseTree(child, depth + 1);
        }
    }
}
 
void TreeCanvas::ExpandAllChildren(EmberCore::ITreeNode *node) {
    if (!node)
        return;
    node->SetChildrenVisible(true);
    for (size_t i = 0; i < node->GetChildCount(); ++i) {
        if (node->GetChild(i))
            ExpandAllChildren(node->GetChild(i));
    }
}
 
void TreeCanvas::CollapseAllChildren(EmberCore::ITreeNode *node) {
    if (!node)
        return;
    node->SetChildrenVisible(false);
    for (size_t i = 0; i < node->GetChildCount(); ++i) {
        if (node->GetChild(i))
            CollapseAllChildren(node->GetChild(i));
    }
}
 
void TreeCanvas::ExpandToDepth(EmberCore::ITreeNode *node, int relativeDepth) {
    if (!node)
        return;
    if (relativeDepth <= 0 || node->GetChildCount() == 0) {
        node->SetChildrenVisible(false);
        return;
    }
    node->SetChildrenVisible(true);
    for (size_t i = 0; i < node->GetChildCount(); ++i) {
        if (node->GetChild(i))
            ExpandToDepth(node->GetChild(i), relativeDepth - 1);
    }
}
 
void TreeCanvas::SetTree(std::shared_ptr<EmberCore::ITreeStructure> tree) {
    m_tree = tree;
    m_selectedNode = nullptr;
    m_hoveredNode = nullptr;
    m_hoveredArrowNode = nullptr;
    m_pressedArrowNode = nullptr;
    m_focusRoot = nullptr;
    m_widthCache.clear();
    m_minimapDirty = true;
 
    if (m_tree && m_tree->HasRootNode() &&
        m_tree->GetNodeCount() > static_cast<size_t>(m_config.autoCollapseThreshold)) {
        AutoCollapseTree(m_tree->GetRootNode(), 0);
    }
 
    if (m_tree && m_tree->HasRootNode()) {
        m_zoomFactor = 0.75f;
        CenterOnNode(m_tree->GetRootNode());
    } else {
        ResetView();
    }
 
    MarkDirty();
}
 
void TreeCanvas::SetSelectedNode(EmberCore::ITreeNode *node) {
    m_selectedNode = node;
    OnNodeSelected(node);
    MarkDirty();
}
 
void TreeCanvas::OnNodeSelected(EmberCore::ITreeNode *node) {
    if (m_selectionCallback) {
        m_selectionCallback(node);
    }
}
 
void TreeCanvas::OnBeforePaintOverlays(wxDC &) {}
 
wxColour TreeCanvas::GetNodeFillColor(EmberCore::ITreeNode *node, bool, bool) {
    wxColour fill = m_config.node_color;
    if (m_statusProvider) {
        int status = m_statusProvider->GetNodeStatus(static_cast<int64_t>(node->GetId()));
        if (status != 0)
            fill = StatusColors::GetFillColor(status);
    }
    return fill;
}
 
wxColour TreeCanvas::GetNodeBorderColor(EmberCore::ITreeNode *node, bool selected, bool hovered) {
    wxColour border = m_config.border_color;
    int64_t nodeId = static_cast<int64_t>(node->GetId());
 
    if (m_statusProvider) {
        int status = m_statusProvider->GetNodeStatus(nodeId);
        if (status != 0)
            border = StatusColors::GetBorderColor(status);
    }
    if (m_executionPathIds.count(nodeId) > 0)
        border = StatusColors::GetExecutionPathColor();
 
    if (selected)
        border = m_config.selected_border_color;
    else if (hovered)
        border = m_config.hovered_border_color;
 
    return border;
}
 
wxColour TreeCanvas::GetNodeTextColor(EmberCore::ITreeNode *node, bool, bool) {
    wxColour text = m_config.text_color;
    if (m_statusProvider) {
        int status = m_statusProvider->GetNodeStatus(static_cast<int64_t>(node->GetId()));
        if (status != 0)
            text = StatusColors::GetTextColor(status);
    }
    return text;
}
 
void TreeCanvas::ResetView() {
    m_zoomFactor = 1.0f;
    wxSize panel_size = GetSize();
    m_viewOffset = {panel_size.GetWidth() / 2, 100};
    m_targetOffset = m_viewOffset;
    MarkDirty();
}
 
void TreeCanvas::FitTreeInView() {
    m_widthCache.clear();
    m_minimapDirty = true;
    wxSize panelSize = GetSize();
 
    if (!m_tree || !m_tree->HasRootNode() || panelSize.GetWidth() <= 0) {
        ResetView();
        return;
    }
 
    int treeWidth = CalculateSubtreeWidth(m_tree->GetRootNode());
 
    if (treeWidth <= panelSize.GetWidth()) {
        ResetView();
        return;
    }
 
    m_zoomFactor = std::max(m_minZoom, static_cast<float>(panelSize.GetWidth()) / static_cast<float>(treeWidth) * 0.9f);
    m_viewOffset = {panelSize.GetWidth() / 2, 30};
    m_targetOffset = m_viewOffset;
    MarkDirty();
}
 
void TreeCanvas::CenterOnNode(EmberCore::ITreeNode *node) {
    if (!node || !m_tree)
        return;
 
    wxSize panel_size = GetSize();
    wxPoint node_world_pos = FindNodeWorldPosition(node);
 
    if (node_world_pos.x != -1 && node_world_pos.y != -1) {
        wxPoint dest = {panel_size.x / 2 - static_cast<int>(node_world_pos.x * m_zoomFactor),
                        panel_size.y / 2 - static_cast<int>(node_world_pos.y * m_zoomFactor)};
        if (m_config.enable_smooth_panning) {
            m_targetOffset = dest;
        } else {
            m_viewOffset = dest;
            m_targetOffset = dest;
        }
    }
    MarkDirty();
}
 
void TreeCanvas::SetZoom(float zoom) {
    m_zoomFactor = std::max(m_minZoom, std::min(m_maxZoom, zoom));
    MarkDirty();
}
 
// --- Event Handlers ---
 
void TreeCanvas::UpdateScaledConfig() {
    m_scaled = m_config;
    m_scaled.node_width = DPI::Scale(this, m_scaled.node_width);
    m_scaled.node_height = DPI::Scale(this, m_scaled.node_height);
    m_scaled.vertical_spacing = DPI::Scale(this, m_scaled.vertical_spacing);
    m_scaled.horizontal_spacing = DPI::Scale(this, m_scaled.horizontal_spacing);
    m_scaled.grid_size = DPI::Scale(this, m_scaled.grid_size);
    m_scaled.type_header_height = DPI::Scale(this, m_scaled.type_header_height);
    m_scaled.title_padding = DPI::Scale(this, m_config.title_padding);
    m_scaled.viewport_culling_margin = DPI::Scale(this, m_config.viewport_culling_margin);
}
 
void TreeCanvas::BuildPathToSelected() {
    m_pathToSelectedIds.clear();
    m_selectedPathSegments.clear();
    if (!m_config.highlight_path_to_selected || !m_selectedNode)
        return;
 
    EmberCore::ITreeNode *curr = m_selectedNode;
    while (curr) {
        m_pathToSelectedIds.insert(curr->GetId());
        curr = curr->GetParent();
    }
}
 
void TreeCanvas::OnPaint(wxPaintEvent &) {
    UpdateScaledConfig();
    wxBufferedPaintDC dc(this);
 
    dc.SetBackground(wxBrush(m_config.background_color));
    dc.Clear();
 
    if (!m_tree || !m_tree->HasRootNode()) {
        dc.SetUserScale(1.0, 1.0);
        dc.SetDeviceOrigin(0, 0);
        wxSize sz = GetSize();
        dc.SetTextForeground(wxColour(128, 128, 128));
        dc.SetFont(wxFont(14, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL));
        wxString msg = "Waiting for tree data...";
        wxCoord tw, th;
        dc.GetTextExtent(msg, &tw, &th);
        dc.DrawText(msg, (sz.x - tw) / 2, sz.y / 2 - th);
        return;
    }
 
    dc.SetUserScale(m_zoomFactor, m_zoomFactor);
    dc.SetDeviceOrigin(m_viewOffset.x, m_viewOffset.y);
 
    wxRect viewport = GetViewportBounds();
 
    if (m_showGrid && m_zoomFactor >= 0.3f) {
        DrawGrid(dc, viewport);
    }
 
    m_executionPathIds.clear();
    m_highlightedSegments.clear();
    m_selectedPathSegments.clear();
    m_collapseArrows.clear();
 
    if (m_statusProvider) {
        m_statusProvider->GetExecutionPathIds(m_executionPathIds);
    }
 
    BuildPathToSelected();
 
    EmberCore::ITreeNode *effectiveRoot = GetEffectiveRoot();
    if (effectiveRoot) {
        wxPoint root_pos = CalculateRootPosition();
        DrawNode(dc, effectiveRoot, root_pos.x, root_pos.y, 0, viewport);
    }
 
    if (!m_highlightedSegments.empty()) {
        wxColour pathColor = StatusColors::GetExecutionPathColor();
        dc.SetPen(wxPen(pathColor, 4));
        for (const auto &seg : m_highlightedSegments) {
            dc.DrawLine(seg.x1, seg.y1, seg.x2, seg.y2);
        }
    }
 
    if (!m_selectedPathSegments.empty()) {
        dc.SetPen(wxPen(m_config.path_highlight_color, 4));
        for (const auto &seg : m_selectedPathSegments) {
            dc.DrawLine(seg.x1, seg.y1, seg.x2, seg.y2);
        }
    }
 
    for (const auto &arrow : m_collapseArrows) {
        DrawCollapseArrow(dc, arrow.node, arrow.x, arrow.y);
    }
 
    OnBeforePaintOverlays(dc);
    DrawOverlayInfo(dc);
    DrawMinimap(dc);
    if (m_showBreadcrumb)
        DrawBreadcrumb(dc);
}
 
void TreeCanvas::OnSize(wxSizeEvent &event) {
    MarkDirty();
    event.Skip();
}
 
void TreeCanvas::OnMouseLeftDown(wxMouseEvent &event) {
    SetFocus();
 
    if (m_config.pan_key_code == -1 && m_config.pan_mouse_button == 1) {
        event.Skip();
        return;
    }
 
    if (!m_tree || !m_tree->HasRootNode()) {
        event.Skip();
        return;
    }
 
    wxPoint mouse_pos = event.GetPosition();
 
    if (m_showMinimap && m_minimapRect.Contains(mouse_pos)) {
        EmberCore::ITreeNode *root = GetEffectiveRoot();
        if (root) {
            wxPoint rootPos = CalculateRootPosition();
            // cppcheck-suppress duplicateAssignExpression
            int treeMinX = rootPos.x;
            int treeMaxX = rootPos.x;
            int treeMaxY = rootPos.y + m_scaled.node_height;
            ComputeTreeExtent(root, rootPos.x, rootPos.y, treeMinX, treeMaxX, treeMaxY);
 
            int treeW = std::max(1, treeMaxX - treeMinX);
            int treeH = std::max(1, treeMaxY - rootPos.y);
 
            int pad = 10;
            float scX = static_cast<float>(m_minimapRect.GetWidth() - 2 * pad) / static_cast<float>(treeW);
            float scY = static_cast<float>(m_minimapRect.GetHeight() - 2 * pad) / static_cast<float>(treeH);
            float sc = std::min(scX, scY);
 
            int ofsX = m_minimapRect.GetLeft() + pad +
                       static_cast<int>((m_minimapRect.GetWidth() - 2 * pad - treeW * sc) / 2.0f);
            int ofsY = m_minimapRect.GetTop() + pad;
 
            float worldX = (mouse_pos.x - ofsX) / sc + treeMinX;
            float worldY = (mouse_pos.y - ofsY) / sc + rootPos.y;
 
            wxSize panelSize = GetSize();
            m_viewOffset.x = panelSize.x / 2 - static_cast<int>(worldX * m_zoomFactor);
            m_viewOffset.y = panelSize.y / 2 - static_cast<int>(worldY * m_zoomFactor);
            m_targetOffset = m_viewOffset;
            MarkDirty();
        }
        return;
    }
 
    for (const auto &bc : m_breadcrumbHitTargets) {
        if (bc.first.Contains(mouse_pos)) {
            if (bc.second == nullptr) {
                ExitFocusMode();
            } else {
                SetSelectedNode(bc.second);
                CenterOnNode(bc.second);
            }
            return;
        }
    }
 
    wxPoint world_pos = ScreenToWorld(mouse_pos);
 
    EmberCore::ITreeNode *arrow_node = FindArrowAtPosition(world_pos);
    if (arrow_node) {
        m_pressedArrowNode = arrow_node;
        bool visible = arrow_node->AreChildrenVisible();
        arrow_node->SetChildrenVisible(!visible);
        m_widthCache.clear();
        m_minimapDirty = true;
        if (m_visibilityChangeCallback)
            m_visibilityChangeCallback();
        MarkDirty();
        return;
    }
 
    wxPoint root_pos = CalculateRootPosition();
 
    EmberCore::ITreeNode *effectiveRoot = GetEffectiveRoot();
    EmberCore::ITreeNode *clicked_node =
        effectiveRoot ? FindNodeAtPosition(effectiveRoot, root_pos, world_pos) : nullptr;
    SetSelectedNode(clicked_node);
}
 
void TreeCanvas::OnMouseLeftUp(wxMouseEvent &event) {
    (void)event;
    if (m_pressedArrowNode) {
        m_pressedArrowNode = nullptr;
        MarkDirty();
    }
}
 
void TreeCanvas::OnMouseLeftDClick(wxMouseEvent &event) {
    if (!m_tree || !m_tree->HasRootNode())
        return;
 
    wxPoint mouse_pos = event.GetPosition();
 
    if (m_showMinimap && m_minimapRect.Contains(mouse_pos))
        return;
 
    wxPoint world_pos = ScreenToWorld(mouse_pos);
    wxPoint root_pos = CalculateRootPosition();
    EmberCore::ITreeNode *effectiveRoot = GetEffectiveRoot();
    EmberCore::ITreeNode *clicked_node =
        effectiveRoot ? FindNodeAtPosition(effectiveRoot, root_pos, world_pos) : nullptr;
 
    if (clicked_node) {
        SetSelectedNode(clicked_node);
        CenterOnNode(clicked_node);
    }
}
 
void TreeCanvas::OnMouseMotion(wxMouseEvent &event) {
    wxPoint mouse_pos = event.GetPosition();
 
    bool shouldPan = false;
    if (m_config.pan_key_code == -1) {
        if (m_config.pan_mouse_button == 1)
            shouldPan = event.LeftIsDown();
        else if (m_config.pan_mouse_button == 2)
            shouldPan = event.MiddleIsDown();
        else if (m_config.pan_mouse_button == 3)
            shouldPan = event.RightIsDown();
    } else {
        shouldPan = m_panKeyHeld;
    }
 
    if (shouldPan) {
        if (!m_isPanning) {
            m_isPanning = true;
            m_lastMousePos = mouse_pos;
        } else {
            wxPoint delta = mouse_pos - m_lastMousePos;
            delta.x = static_cast<int>(delta.x * m_config.pan_sensitivity);
            delta.y = static_cast<int>(delta.y * m_config.pan_sensitivity);
            m_viewOffset += delta;
            m_targetOffset = m_viewOffset;
            m_lastMousePos = mouse_pos;
            MarkDirty();
        }
        return;
    }
 
    if (m_isPanning) {
        m_isPanning = false;
    }
 
    EmberCore::ITreeNode *effectiveRoot = GetEffectiveRoot();
    if (effectiveRoot) {
        wxPoint world_pos = ScreenToWorld(mouse_pos);
        EmberCore::ITreeNode *arrow_hovered = FindArrowAtPosition(world_pos);
 
        if (arrow_hovered) {
            if (arrow_hovered != m_hoveredArrowNode) {
                m_hoveredArrowNode = arrow_hovered;
                m_hoveredNode = nullptr;
                MarkDirty();
            }
        } else {
            if (m_hoveredArrowNode) {
                m_hoveredArrowNode = nullptr;
                MarkDirty();
            }
            wxPoint root_pos = CalculateRootPosition();
            EmberCore::ITreeNode *new_hovered = FindNodeAtPosition(effectiveRoot, root_pos, world_pos);
            if (new_hovered != m_hoveredNode) {
                m_hoveredNode = new_hovered;
                MarkDirty();
            }
        }
    }
}
 
void TreeCanvas::OnMouseWheel(wxMouseEvent &event) {
    float old_zoom = m_zoomFactor;
 
    float zoom_delta =
        (event.GetWheelRotation() > 0 ? m_config.zoom_step : -m_config.zoom_step) * m_config.mouse_wheel_sensitivity;
    m_zoomFactor += zoom_delta;
    m_zoomFactor = std::max(m_minZoom, std::min(m_maxZoom, m_zoomFactor));
 
    if (old_zoom != m_zoomFactor) {
        if (m_config.zoom_follows_cursor) {
            wxPoint mouse_screen = event.GetPosition();
            wxPoint mouse_world = {static_cast<int>((mouse_screen.x - m_viewOffset.x) / old_zoom),
                                   static_cast<int>((mouse_screen.y - m_viewOffset.y) / old_zoom)};
 
            m_viewOffset.x = mouse_screen.x - static_cast<int>(mouse_world.x * m_zoomFactor);
            m_viewOffset.y = mouse_screen.y - static_cast<int>(mouse_world.y * m_zoomFactor);
            m_targetOffset = m_viewOffset;
        }
        MarkDirty();
    }
}
 
void TreeCanvas::OnMouseMiddleDown(wxMouseEvent &event) {
    m_isPanning = true;
    m_lastMousePos = event.GetPosition();
}
 
void TreeCanvas::OnMouseMiddleUp(wxMouseEvent &) { m_isPanning = false; }
 
void TreeCanvas::OnKeyDown(wxKeyEvent &event) {
    int keyCode = event.GetKeyCode();
 
    if (keyCode == m_config.pan_key_code && m_config.pan_key_code != -1) {
        m_panKeyHeld = true;
        return;
    }
 
    float pan_step = m_config.pan_step_size * m_config.pan_sensitivity;
 
    switch (keyCode) {
    case WXK_UP:
        m_targetOffset.y += static_cast<int>(pan_step);
        break;
    case WXK_DOWN:
        m_targetOffset.y -= static_cast<int>(pan_step);
        break;
    case WXK_LEFT:
        m_targetOffset.x += static_cast<int>(pan_step);
        break;
    case WXK_RIGHT:
        m_targetOffset.x -= static_cast<int>(pan_step);
        break;
    case 'R':
        ResetView();
        break;
    case 'E':
        if (m_selectedNode && m_selectedNode->GetChildCount() > 0) {
            bool visible = m_selectedNode->AreChildrenVisible();
            m_selectedNode->SetChildrenVisible(!visible);
            m_widthCache.clear();
            m_minimapDirty = true;
            if (m_visibilityChangeCallback)
                m_visibilityChangeCallback();
        }
        break;
    case 'F':
        if (m_selectedNode && m_selectedNode->GetChildCount() > 0) {
            EnterFocusMode(m_selectedNode);
        } else {
            FitTreeInView();
        }
        break;
    case WXK_ESCAPE:
        if (m_focusRoot) {
            ExitFocusMode();
        }
        break;
    default:
        event.Skip();
        return;
    }
 
    MarkDirty();
}
 
void TreeCanvas::OnKeyUp(wxKeyEvent &event) {
    int keyCode = event.GetKeyCode();
    if (keyCode == m_config.pan_key_code && m_config.pan_key_code != -1) {
        m_panKeyHeld = false;
        m_isPanning = false;
        return;
    }
    event.Skip();
}
 
void TreeCanvas::OnMouseRightUp(wxMouseEvent &event) {
    if (!m_tree || !m_tree->HasRootNode()) {
        event.Skip();
        return;
    }
 
    wxPoint mouse_pos = event.GetPosition();
    wxPoint world_pos = ScreenToWorld(mouse_pos);
    wxPoint root_pos = CalculateRootPosition();
 
    EmberCore::ITreeNode *effectiveRoot = GetEffectiveRoot();
    EmberCore::ITreeNode *clicked_node =
        effectiveRoot ? FindNodeAtPosition(effectiveRoot, root_pos, world_pos) : nullptr;
 
    if (clicked_node) {
        SetSelectedNode(clicked_node);
    }
 
    enum {
        ID_EXPAND_ALL = wxID_HIGHEST + 100,
        ID_COLLAPSE_ALL,
        ID_EXPAND_DEPTH_1,
        ID_EXPAND_DEPTH_2,
        ID_EXPAND_DEPTH_3,
        ID_FOCUS_HERE,
        ID_CENTER_NODE,
        ID_FIT_VIEW,
        ID_RESET_VIEW
    };
 
    wxMenu menu;
 
    if (clicked_node && clicked_node->GetChildCount() > 0) {
        menu.Append(ID_EXPAND_ALL, "Expand All");
        menu.Append(ID_COLLAPSE_ALL, "Collapse All");
        menu.AppendSeparator();
        menu.Append(ID_EXPAND_DEPTH_1, "Expand to Depth 1");
        menu.Append(ID_EXPAND_DEPTH_2, "Expand to Depth 2");
        menu.Append(ID_EXPAND_DEPTH_3, "Expand to Depth 3");
        menu.AppendSeparator();
        menu.Append(ID_FOCUS_HERE, "Focus Here");
        menu.Append(ID_CENTER_NODE, "Center on Node");
 
        menu.Bind(
            wxEVT_MENU,
            [this, clicked_node](wxCommandEvent &) {
                ExpandAllChildren(clicked_node);
                m_widthCache.clear();
                m_minimapDirty = true;
                MarkDirty();
                if (m_visibilityChangeCallback)
                    m_visibilityChangeCallback();
            },
            ID_EXPAND_ALL);
 
        menu.Bind(
            wxEVT_MENU,
            [this, clicked_node](wxCommandEvent &) {
                CollapseAllChildren(clicked_node);
                m_widthCache.clear();
                m_minimapDirty = true;
                MarkDirty();
                if (m_visibilityChangeCallback)
                    m_visibilityChangeCallback();
            },
            ID_COLLAPSE_ALL);
 
        menu.Bind(
            wxEVT_MENU,
            [this, clicked_node](wxCommandEvent &) {
                ExpandToDepth(clicked_node, 1);
                m_widthCache.clear();
                m_minimapDirty = true;
                MarkDirty();
                if (m_visibilityChangeCallback)
                    m_visibilityChangeCallback();
            },
            ID_EXPAND_DEPTH_1);
 
        menu.Bind(
            wxEVT_MENU,
            [this, clicked_node](wxCommandEvent &) {
                ExpandToDepth(clicked_node, 2);
                m_widthCache.clear();
                m_minimapDirty = true;
                MarkDirty();
                if (m_visibilityChangeCallback)
                    m_visibilityChangeCallback();
            },
            ID_EXPAND_DEPTH_2);
 
        menu.Bind(
            wxEVT_MENU,
            [this, clicked_node](wxCommandEvent &) {
                ExpandToDepth(clicked_node, 3);
                m_widthCache.clear();
                m_minimapDirty = true;
                MarkDirty();
                if (m_visibilityChangeCallback)
                    m_visibilityChangeCallback();
            },
            ID_EXPAND_DEPTH_3);
 
        menu.Bind(
            wxEVT_MENU, [this, clicked_node](wxCommandEvent &) { EnterFocusMode(clicked_node); }, ID_FOCUS_HERE);
 
        menu.Bind(
            wxEVT_MENU, [this, clicked_node](wxCommandEvent &) { CenterOnNode(clicked_node); }, ID_CENTER_NODE);
    } else {
        EmberCore::ITreeNode *root = GetEffectiveRoot();
 
        menu.Append(ID_EXPAND_ALL, "Expand All");
        menu.Append(ID_COLLAPSE_ALL, "Collapse All");
        menu.AppendSeparator();
        menu.Append(ID_FIT_VIEW, "Fit Tree in View");
        menu.Append(ID_RESET_VIEW, "Reset View");
 
        menu.Bind(
            wxEVT_MENU,
            [this, root](wxCommandEvent &) {
                if (root)
                    ExpandAllChildren(root);
                m_widthCache.clear();
                m_minimapDirty = true;
                MarkDirty();
                if (m_visibilityChangeCallback)
                    m_visibilityChangeCallback();
            },
            ID_EXPAND_ALL);
 
        menu.Bind(
            wxEVT_MENU,
            [this, root](wxCommandEvent &) {
                if (root)
                    CollapseAllChildren(root);
                m_widthCache.clear();
                m_minimapDirty = true;
                MarkDirty();
                if (m_visibilityChangeCallback)
                    m_visibilityChangeCallback();
            },
            ID_COLLAPSE_ALL);
 
        menu.Bind(
            wxEVT_MENU, [this](wxCommandEvent &) { FitTreeInView(); }, ID_FIT_VIEW);
 
        menu.Bind(
            wxEVT_MENU, [this](wxCommandEvent &) { ResetView(); }, ID_RESET_VIEW);
    }
 
    PopupMenu(&menu, mouse_pos);
}
 
// --- Drawing Methods ---
 
void TreeCanvas::DrawGrid(wxDC &dc, const wxRect &viewport) {
    dc.SetBrush(wxBrush(m_config.background_color));
    dc.SetPen(*wxTRANSPARENT_PEN);
    dc.DrawRectangle(viewport);
 
    dc.SetPen(wxPen(m_config.grid_color, 1));
    dc.SetBrush(*wxTRANSPARENT_BRUSH);
 
    int gridSpacing = m_scaled.grid_size;
    if (m_zoomFactor < 0.5f)
        gridSpacing = m_scaled.grid_size * 4;
    else if (m_zoomFactor < 0.8f)
        gridSpacing = m_scaled.grid_size * 2;
    else if (m_zoomFactor > 2.0f)
        gridSpacing = m_scaled.grid_size / 2;
 
    int startX = (viewport.GetLeft() / gridSpacing) * gridSpacing;
    for (int x = startX; x <= viewport.GetRight(); x += gridSpacing) {
        dc.DrawLine(x, viewport.GetTop(), x, viewport.GetBottom());
    }
 
    int startY = (viewport.GetTop() / gridSpacing) * gridSpacing;
    for (int y = startY; y <= viewport.GetBottom(); y += gridSpacing) {
        dc.DrawLine(viewport.GetLeft(), y, viewport.GetRight(), y);
    }
}
 
void TreeCanvas::DrawNode(wxDC &dc, EmberCore::ITreeNode *node, wxCoord x, wxCoord y, int level,
                          const wxRect &viewport) {
    if (!node)
        return;
 
    int margin =
        m_config.enable_viewport_culling ? static_cast<int>(m_config.viewport_culling_margin / m_zoomFactor) : 100000;
 
    if (y > viewport.GetBottom() + margin) {
        return;
    }
 
    int subtreeWidth = CalculateSubtreeWidth(node);
 
    if (m_config.enable_viewport_culling) {
        if (x + subtreeWidth / 2 < viewport.GetLeft() - margin || x - subtreeWidth / 2 > viewport.GetRight() + margin) {
            return;
        }
    }
 
    bool nodeVisible = (y + m_scaled.node_height >= viewport.GetTop() - margin);
 
    if (nodeVisible) {
        DrawNodeBox(dc, node, x, y);
        DrawNodeText(dc, node, x, y);
 
        if (node->GetChildCount() > 0) {
            m_collapseArrows.push_back({node, x, y});
        }
    }
 
    if (node->AreChildrenVisible() && node->GetChildCount() > 0) {
        if (nodeVisible) {
            DrawNodeConnections(dc, node, x, y);
        }
 
        int total_width = subtreeWidth;
        wxCoord child_x = x - total_width / 2;
        wxCoord child_y = y + m_scaled.node_height + m_scaled.vertical_spacing;
 
        for (size_t i = 0; i < node->GetChildCount(); ++i) {
            EmberCore::ITreeNode *child = node->GetChild(i);
            if (child) {
                int child_subtree_width = CalculateSubtreeWidth(child);
                wxCoord center_x = child_x + child_subtree_width / 2;
                DrawNode(dc, child, center_x, child_y, level + 1, viewport);
                child_x += child_subtree_width;
            }
        }
    }
}
 
void TreeCanvas::DrawNodeBox(wxDC &dc, EmberCore::ITreeNode *node, wxCoord x, wxCoord y) {
    bool isSelected = (m_selectedNode && node->GetId() == m_selectedNode->GetId());
    bool isHovered = (node == m_hoveredNode);
 
    wxColour fill_color = GetNodeFillColor(node, isSelected, isHovered);
    wxColour border_color = GetNodeBorderColor(node, isSelected, isHovered);
 
    int border_width = 1;
    int64_t nodeId = static_cast<int64_t>(node->GetId());
    if (m_statusProvider && m_statusProvider->GetNodeStatus(nodeId) != 0)
        border_width = 2;
    if (m_executionPathIds.count(nodeId) > 0)
        border_width = 3;
    if (isSelected)
        border_width = 3;
    else if (isHovered)
        border_width = 2;
 
    dc.SetBrush(wxBrush(fill_color));
    dc.SetPen(wxPen(border_color, border_width));
 
    wxRect node_rect(x - m_scaled.node_width / 2, y, m_scaled.node_width, m_scaled.node_height);
 
    if (m_zoomFactor < 0.25f) {
        dc.DrawRectangle(node_rect);
    } else {
        dc.DrawRoundedRectangle(node_rect, 5);
    }
 
    DrawTypeHeader(dc, node, node_rect);
}
 
void TreeCanvas::DrawTypeHeader(wxDC &dc, EmberCore::ITreeNode *node, const wxRect &nodeRect) {
    wxColour typeColor = GetNodeTypeColor(node->GetType());
    int headerH = m_scaled.type_header_height;
    wxRect headerRect(nodeRect.GetLeft() + 1, nodeRect.GetTop() + 1, nodeRect.GetWidth() - 2, headerH);
 
    dc.SetBrush(wxBrush(typeColor));
    dc.SetPen(*wxTRANSPARENT_PEN);
    dc.DrawRectangle(headerRect);
 
    if (m_zoomFactor < 0.5f)
        return;
 
    int contentX = headerRect.GetLeft() + 4;
    int contentCenterY = headerRect.GetTop() + headerH / 2;
 
    auto iconIt = m_typeIcons.find(node->GetType());
    if (m_config.show_type_icons && iconIt != m_typeIcons.end() && iconIt->second.IsOk()) {
        const wxBitmap &icon = iconIt->second;
        int iconH = icon.GetHeight();
 
        double savedScaleX, savedScaleY;
        dc.GetUserScale(&savedScaleX, &savedScaleY);
        wxPoint savedOrigin = dc.GetDeviceOrigin();
 
        dc.SetUserScale(1.0, 1.0);
        dc.SetDeviceOrigin(0, 0);
 
        int screenX = static_cast<int>(contentX * savedScaleX) + savedOrigin.x;
        int screenY = static_cast<int>((contentCenterY - iconH / 2) * savedScaleY) + savedOrigin.y;
 
        dc.DrawBitmap(icon, screenX, screenY, true);
 
        dc.SetUserScale(savedScaleX, savedScaleY);
        dc.SetDeviceOrigin(savedOrigin.x, savedOrigin.y);
 
        contentX += static_cast<int>(icon.GetWidth() / savedScaleX) + 3;
    }
 
    if (m_config.show_type_text) {
        dc.SetFont(m_headerFont);
        dc.SetTextForeground(m_config.type_header_text_color);
 
        wxString typeStr = node->GetTypeString();
        wxCoord tw, th;
        dc.GetTextExtent(typeStr, &tw, &th);
 
        int maxTextW = headerRect.GetRight() - contentX - 4;
        if (tw > maxTextW && maxTextW > 0) {
            size_t lo = 0, hi = typeStr.Length();
            while (lo < hi) {
                size_t mid = (lo + hi + 1) / 2;
                dc.GetTextExtent(typeStr.Left(mid) + "..", &tw, &th);
                if (tw <= maxTextW)
                    lo = mid;
                else
                    hi = mid - 1;
            }
            typeStr = (lo > 0 ? typeStr.Left(lo) : wxString()) + "..";
            dc.GetTextExtent(typeStr, &tw, &th);
        }
 
        dc.DrawText(typeStr, contentX, contentCenterY - th / 2);
    }
}
 
void TreeCanvas::DrawNodeText(wxDC &dc, EmberCore::ITreeNode *node, wxCoord x, wxCoord y) {
    if (m_zoomFactor < 0.25f)
        return;
 
    bool isSelected = (m_selectedNode && node->GetId() == m_selectedNode->GetId());
    bool isHovered = (node == m_hoveredNode);
    wxColour text_color = GetNodeTextColor(node, isSelected, isHovered);
    dc.SetTextForeground(text_color);
 
    int textStartY = y + m_scaled.type_header_height + 2;
 
    dc.SetFont(m_titleFont);
    EmberCore::String text = node->GetName();
    wxCoord tw, th;
    dc.GetTextExtent(text, &tw, &th);
 
    int maxW = m_scaled.node_width - 20;
    if (tw > m_scaled.node_width - 10 && maxW > 0) {
        size_t lo = 0, hi = text.length();
        while (lo < hi) {
            size_t mid = (lo + hi + 1) / 2;
            wxCoord mw, mh;
            dc.GetTextExtent(wxString(text.substr(0, mid) + "..."), &mw, &mh);
            if (mw <= maxW)
                lo = mid;
            else
                hi = mid - 1;
        }
        text = (lo > 0 ? text.substr(0, lo) : EmberCore::String()) + "...";
        dc.GetTextExtent(text, &tw, &th);
    }
 
    dc.DrawText(text, x - tw / 2, textStartY + 2);
}
 
void TreeCanvas::DrawNodeConnections(wxDC &dc, EmberCore::ITreeNode *node, wxCoord x, wxCoord y) {
    if (!node->AreChildrenVisible() || node->GetChildCount() == 0)
        return;
 
    int total_width = CalculateSubtreeWidth(node);
    wxCoord child_y = y + m_scaled.node_height + m_scaled.vertical_spacing;
 
    int64_t parentId = static_cast<int64_t>(node->GetId());
    bool parentInExecPath = m_executionPathIds.count(parentId) > 0;
    bool parentInSelectedPath = m_pathToSelectedIds.count(node->GetId()) > 0;
 
    dc.SetPen(wxPen(m_config.connection_color, 2));
    dc.DrawLine(x, y + m_scaled.node_height, x, child_y - 10);
 
    if (parentInExecPath)
        m_highlightedSegments.push_back({x, y + m_scaled.node_height, x, child_y - 10});
    if (parentInSelectedPath)
        m_selectedPathSegments.push_back({x, y + m_scaled.node_height, x, child_y - 10});
 
    wxCoord child_x = x - total_width / 2;
 
    for (size_t i = 0; i < node->GetChildCount(); ++i) {
        EmberCore::ITreeNode *child = node->GetChild(i);
        if (child) {
            int subtree_width = CalculateSubtreeWidth(child);
            wxCoord center_x = child_x + subtree_width / 2;
 
            int64_t childId = static_cast<int64_t>(child->GetId());
            bool childInExecPath = m_executionPathIds.count(childId) > 0;
            bool childInSelectedPath = m_pathToSelectedIds.count(child->GetId()) > 0;
 
            dc.SetPen(wxPen(m_config.connection_color, 2));
            dc.DrawLine(x, child_y - 10, center_x, child_y - 10);
            dc.DrawLine(center_x, child_y - 10, center_x, child_y);
 
            if (parentInExecPath && childInExecPath) {
                m_highlightedSegments.push_back({x, child_y - 10, center_x, child_y - 10});
                m_highlightedSegments.push_back({center_x, child_y - 10, center_x, child_y});
            }
            if (parentInSelectedPath && childInSelectedPath) {
                m_selectedPathSegments.push_back({x, child_y - 10, center_x, child_y - 10});
                m_selectedPathSegments.push_back({center_x, child_y - 10, center_x, child_y});
            }
 
            child_x += subtree_width;
        }
    }
}
 
void TreeCanvas::DrawCollapseArrow(wxDC &dc, EmberCore::ITreeNode *node, wxCoord x, wxCoord y) {
    if (node->GetChildCount() == 0)
        return;
 
    bool isHovered = (node == m_hoveredArrowNode);
    bool isPressed = (node == m_pressedArrowNode);
 
    int circle_radius = 8;
    wxCoord arrow_x = x;
    wxCoord arrow_y = y + m_scaled.node_height;
 
    wxColour circleFill(70, 70, 70), circlePen(100, 100, 100);
    if (isPressed) {
        circleFill = wxColour(50, 50, 50);
        circlePen = wxColour(80, 80, 80);
    } else if (isHovered) {
        circleFill = wxColour(90, 90, 90);
        circlePen = wxColour(130, 130, 130);
    }
    dc.SetBrush(wxBrush(circleFill));
    dc.SetPen(wxPen(circlePen, 1));
    dc.DrawCircle(arrow_x, arrow_y, circle_radius);
 
    wxPoint triangle[3];
    wxColour triFill, triPen;
 
    if (node->AreChildrenVisible()) {
        int sz = 5;
        triangle[0] = {arrow_x - sz, arrow_y - 2};
        triangle[1] = {arrow_x + sz, arrow_y - 2};
        triangle[2] = {arrow_x, arrow_y + 3};
        triFill = isPressed ? wxColour(100, 180, 235) : (isHovered ? wxColour(150, 220, 255) : wxColour(120, 200, 255));
        triPen = triFill;
    } else {
        int sz = 5;
        triangle[0] = {arrow_x - 2, arrow_y - sz};
        triangle[1] = {arrow_x - 2, arrow_y + sz};
        triangle[2] = {arrow_x + 3, arrow_y};
        triFill = isPressed ? wxColour(140, 140, 140) : (isHovered ? wxColour(220, 220, 220) : wxColour(180, 180, 180));
        triPen = triFill;
    }
    dc.SetPen(wxPen(triPen, 1));
    dc.SetBrush(wxBrush(triFill));
    dc.DrawPolygon(3, triangle);
}
 
void TreeCanvas::DrawOverlayInfo(wxDC &dc) {
    if (!m_showOverlayInfo)
        return;
 
    dc.SetUserScale(1.0, 1.0);
    dc.SetDeviceOrigin(0, 0);
 
    wxSize panel_size = GetSize();
 
    int topOffset = m_selectedNode ? 28 : 4;
 
    dc.SetTextForeground(wxColour(150, 150, 150));
    dc.SetFont(wxFont(9, wxFONTFAMILY_TELETYPE, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL));
 
    wxString zoomText =
        wxString::Format("Zoom: %.0f%% | Pan: (%d, %d)", m_zoomFactor * 100, m_viewOffset.x, m_viewOffset.y);
    if (m_focusRoot) {
        zoomText += " | FOCUS MODE";
    }
    dc.DrawText(zoomText, 10, topOffset);
 
    if (m_selectedNode) {
        EmberCore::String selectedText =
            "Selected: " + m_selectedNode->GetName() + " [" + m_selectedNode->GetTypeString() + "]";
        dc.DrawText(selectedText, 10, topOffset + 18);
 
        if (m_statusProvider) {
            int status = m_statusProvider->GetNodeStatus(static_cast<int64_t>(m_selectedNode->GetId()));
            wxString statusNames[] = {"Idle", "Running", "Success", "Failure", "Halted"};
            wxString statusText = "Status: " + (status >= 0 && status <= 4 ? statusNames[status] : "Unknown");
            dc.DrawText(statusText, 10, topOffset + 36);
        }
    }
 
    if (m_tree && m_tree->HasRootNode()) {
        wxString statsText = wxString::Format("Nodes: %lu", static_cast<unsigned long>(m_tree->GetNodeCount()));
        wxCoord tw, th;
        dc.GetTextExtent(statsText, &tw, &th);
        dc.DrawText(statsText, panel_size.x - tw - 10, topOffset);
    }
 
    dc.SetFont(wxFont(8, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL));
    dc.SetTextForeground(wxColour(100, 100, 100));
    wxString hints = "Click=Select | DblClick=Center | Wheel=Zoom | "
                     "R=Reset | E=Collapse | F=Focus";
    if (m_focusRoot)
        hints += " | Esc=Exit Focus";
    dc.DrawText(hints, 10, panel_size.y - 20);
}
 
void TreeCanvas::EnterFocusMode(EmberCore::ITreeNode *node) {
    if (!node)
        return;
    m_focusRoot = node;
    m_widthCache.clear();
    m_minimapDirty = true;
    m_zoomFactor = 0.75f;
    CenterOnNode(node);
    MarkDirty();
}
 
void TreeCanvas::ExitFocusMode() {
    m_focusRoot = nullptr;
    m_widthCache.clear();
    m_minimapDirty = true;
    if (m_tree && m_tree->HasRootNode()) {
        m_zoomFactor = 0.75f;
        CenterOnNode(m_tree->GetRootNode());
    }
    MarkDirty();
}
 
EmberCore::ITreeNode *TreeCanvas::GetEffectiveRoot() const {
    if (m_focusRoot)
        return m_focusRoot;
    if (m_tree && m_tree->HasRootNode())
        return m_tree->GetRootNode();
    return nullptr;
}
 
wxColour TreeCanvas::GetNodeTypeColor(EmberCore::ITreeNode::NodeType type) const {
    switch (type) {
    case EmberCore::ITreeNode::NodeType::Action:
        return m_config.action_type_color;
    case EmberCore::ITreeNode::NodeType::Control:
        return m_config.control_type_color;
    case EmberCore::ITreeNode::NodeType::Condition:
        return m_config.condition_type_color;
    case EmberCore::ITreeNode::NodeType::Decorator:
        return m_config.decorator_type_color;
    case EmberCore::ITreeNode::NodeType::BehaviorTree:
        return m_config.behavior_tree_type_color;
    default:
        return m_config.border_color;
    }
}
 
void TreeCanvas::ComputeTreeExtent(EmberCore::ITreeNode *node, wxCoord x, wxCoord y, int &minX, int &maxX, int &maxY) {
    if (!node)
        return;
 
    int halfW = m_scaled.node_width / 2;
    if (x - halfW < minX)
        minX = x - halfW;
    if (x + halfW > maxX)
        maxX = x + halfW;
    if (y + m_scaled.node_height > maxY)
        maxY = y + m_scaled.node_height;
 
    if (node->AreChildrenVisible() && node->GetChildCount() > 0) {
        int totalW = CalculateSubtreeWidth(node);
        wxCoord cx = x - totalW / 2;
        wxCoord cy = y + m_scaled.node_height + m_scaled.vertical_spacing;
        for (size_t i = 0; i < node->GetChildCount(); ++i) {
            EmberCore::ITreeNode *child = node->GetChild(i);
            if (child) {
                int csw = CalculateSubtreeWidth(child);
                ComputeTreeExtent(child, cx + csw / 2, cy, minX, maxX, maxY);
                cx += csw;
            }
        }
    }
}
 
void TreeCanvas::DrawMinimap(wxDC &dc) {
    if (!m_showMinimap || !m_tree || !m_tree->HasRootNode())
        return;
 
    dc.SetUserScale(1.0, 1.0);
    dc.SetDeviceOrigin(0, 0);
 
    wxSize panelSize = GetSize();
    int mmW = 200, mmH = 150;
    int mmX = 10;
    int mmY = panelSize.y - mmH - 30;
 
    m_minimapRect = wxRect(mmX, mmY, mmW, mmH);
 
    if (m_minimapDirty || !m_minimapCache.IsOk() || m_minimapCache.GetWidth() != mmW ||
        m_minimapCache.GetHeight() != mmH) {
 
        m_minimapCache = wxBitmap(mmW, mmH, 32);
        wxMemoryDC memDC(m_minimapCache);
        memDC.SetBackground(wxBrush(wxColour(30, 30, 30)));
        memDC.Clear();
 
        EmberCore::ITreeNode *root = GetEffectiveRoot();
        if (root) {
            wxPoint rootPos = CalculateRootPosition();
            int treeMinX = rootPos.x;
            int treeMaxX = rootPos.x;
            int treeMaxY = rootPos.y + m_scaled.node_height;
            ComputeTreeExtent(root, rootPos.x, rootPos.y, treeMinX, treeMaxX, treeMaxY);
 
            int treeW = std::max(1, treeMaxX - treeMinX);
            int treeH = std::max(1, treeMaxY - rootPos.y);
 
            int pad = 10;
            float scaleX = static_cast<float>(mmW - 2 * pad) / static_cast<float>(treeW);
            float scaleY = static_cast<float>(mmH - 2 * pad) / static_cast<float>(treeH);
            float scale = std::min(scaleX, scaleY);
 
            int ofsX = pad + static_cast<int>((mmW - 2 * pad - treeW * scale) / 2.0f);
            int ofsY = pad;
 
            DrawMinimapNode(memDC, root, rootPos.x, rootPos.y, scale, scale, ofsX - static_cast<int>(treeMinX * scale),
                            ofsY - static_cast<int>(rootPos.y * scale), wxRect(0, 0, mmW, mmH));
 
            m_minimapCacheTreeMinX = treeMinX;
            m_minimapCacheRootY = rootPos.y;
            m_minimapCacheScale = scale;
            m_minimapCacheOfsX = ofsX;
            m_minimapCacheOfsY = ofsY;
        }
 
        memDC.SelectObject(wxNullBitmap);
        m_minimapDirty = false;
    }
 
    dc.SetPen(wxPen(wxColour(80, 80, 80), 1));
    dc.SetBrush(*wxTRANSPARENT_BRUSH);
    dc.DrawBitmap(m_minimapCache, mmX, mmY, false);
    dc.DrawRectangle(m_minimapRect);
 
    wxRect viewport = GetViewportBounds();
    int vx = mmX + m_minimapCacheOfsX +
             static_cast<int>((viewport.GetLeft() - m_minimapCacheTreeMinX) * m_minimapCacheScale);
    int vy =
        mmY + m_minimapCacheOfsY + static_cast<int>((viewport.GetTop() - m_minimapCacheRootY) * m_minimapCacheScale);
    int vw = static_cast<int>(viewport.GetWidth() * m_minimapCacheScale);
    int vh = static_cast<int>(viewport.GetHeight() * m_minimapCacheScale);
 
    dc.SetBrush(*wxTRANSPARENT_BRUSH);
    dc.SetPen(wxPen(wxColour(255, 255, 255, 180), 1));
    dc.DrawRectangle(std::max(vx, mmX), std::max(vy, mmY), std::min(vw, mmW), std::min(vh, mmH));
}
 
void TreeCanvas::DrawMinimapNode(wxDC &dc, EmberCore::ITreeNode *node, wxCoord x, wxCoord y, float scaleX, float scaleY,
                                 int offsetX, int offsetY, const wxRect &minimapArea) {
    if (!node)
        return;
 
    int sx = offsetX + static_cast<int>(x * scaleX);
    int sy = offsetY + static_cast<int>(y * scaleY);
    int sw = std::max(2, static_cast<int>(m_scaled.node_width * scaleX));
    int sh = std::max(2, static_cast<int>(m_scaled.node_height * scaleY));
 
    wxColour fill = GetNodeTypeColor(node->GetType());
    if (m_statusProvider) {
        int status = m_statusProvider->GetNodeStatus(static_cast<int64_t>(node->GetId()));
        if (status != 0) {
            fill = StatusColors::GetFillColor(status);
        }
    }
 
    dc.SetBrush(wxBrush(fill));
    dc.SetPen(*wxTRANSPARENT_PEN);
    dc.DrawRectangle(sx - sw / 2, sy, sw, sh);
 
    if (node->AreChildrenVisible() && node->GetChildCount() > 0) {
        int totalW = CalculateSubtreeWidth(node);
        wxCoord cx = x - totalW / 2;
        wxCoord cy = y + m_scaled.node_height + m_scaled.vertical_spacing;
        for (size_t i = 0; i < node->GetChildCount(); ++i) {
            EmberCore::ITreeNode *child = node->GetChild(i);
            if (child) {
                int csw = CalculateSubtreeWidth(child);
                DrawMinimapNode(dc, child, cx + csw / 2, cy, scaleX, scaleY, offsetX, offsetY, minimapArea);
                cx += csw;
            }
        }
    }
}
 
void TreeCanvas::DrawBreadcrumb(wxDC &dc) {
    if (!m_selectedNode)
        return;
 
    dc.SetUserScale(1.0, 1.0);
    dc.SetDeviceOrigin(0, 0);
 
    wxSize panelSize = GetSize();
    int barH = 24;
 
    dc.SetBrush(wxBrush(wxColour(35, 35, 35, 220)));
    dc.SetPen(*wxTRANSPARENT_PEN);
    dc.DrawRectangle(0, 0, panelSize.x, barH);
 
    std::vector<EmberCore::ITreeNode *> ancestors;
    EmberCore::ITreeNode *curr = m_selectedNode;
    while (curr) {
        ancestors.push_back(curr);
        curr = curr->GetParent();
    }
    std::reverse(ancestors.begin(), ancestors.end());
 
    if (m_focusRoot) {
        bool foundFocus = false;
        std::vector<EmberCore::ITreeNode *> trimmed;
        for (auto *a : ancestors) {
            if (a == m_focusRoot)
                foundFocus = true;
            if (foundFocus)
                trimmed.push_back(a);
        }
        if (!trimmed.empty())
            ancestors = trimmed;
    }
 
    m_breadcrumbHitTargets.clear();
 
    wxFont bcFont(9, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);
    dc.SetFont(bcFont);
 
    int xPos = 10;
    int yCenter = barH / 2;
 
    if (m_focusRoot) {
        wxString label = "Full Tree";
        wxCoord tw, th;
        dc.GetTextExtent(label, &tw, &th);
 
        dc.SetTextForeground(wxColour(100, 180, 255));
        dc.DrawText(label, xPos, yCenter - th / 2);
        m_breadcrumbHitTargets.push_back({wxRect(xPos, 0, tw, barH), nullptr});
        xPos += tw;
 
        dc.SetTextForeground(wxColour(100, 100, 100));
        dc.DrawText(" > ", xPos, yCenter - th / 2);
        xPos += 20;
    }
 
    for (size_t i = 0; i < ancestors.size(); ++i) {
        EmberCore::ITreeNode *node = ancestors[i];
        bool isLast = (i == ancestors.size() - 1);
 
        wxString name = node->GetName();
        if (name.length() > 20)
            name = name.Left(17) + "...";
 
        wxCoord tw, th;
        dc.GetTextExtent(name, &tw, &th);
 
        if (xPos + tw > panelSize.x - 20) {
            dc.SetTextForeground(wxColour(100, 100, 100));
            dc.DrawText("...", xPos, yCenter - th / 2);
            break;
        }
 
        dc.SetTextForeground(isLast ? wxColour(255, 255, 255) : wxColour(150, 200, 255));
        dc.DrawText(name, xPos, yCenter - th / 2);
        m_breadcrumbHitTargets.push_back({wxRect(xPos, 0, tw, barH), node});
        xPos += tw;
 
        if (!isLast) {
            dc.SetTextForeground(wxColour(100, 100, 100));
            dc.DrawText(" > ", xPos, yCenter - th / 2);
            xPos += 20;
        }
    }
}
 
// --- Utility Methods ---
 
int TreeCanvas::CalculateSubtreeWidth(EmberCore::ITreeNode *node) {
    if (!node)
        return 0;
 
    auto it = m_widthCache.find(node);
    if (it != m_widthCache.end()) {
        return it->second;
    }
 
    int width;
    if (!node->AreChildrenVisible() || node->GetChildCount() == 0) {
        width = m_scaled.node_width + m_scaled.horizontal_spacing;
    } else {
        int total_width = 0;
        for (size_t i = 0; i < node->GetChildCount(); ++i) {
            EmberCore::ITreeNode *child = node->GetChild(i);
            if (child) {
                total_width += CalculateSubtreeWidth(child);
            }
        }
        width = std::max(total_width, m_scaled.node_width + m_scaled.horizontal_spacing);
    }
 
    m_widthCache[node] = width;
    return width;
}
 
wxPoint TreeCanvas::CalculateRootPosition() { return {0, 50}; }
 
EmberCore::ITreeNode *TreeCanvas::FindNodeAtPosition(EmberCore::ITreeNode *node, wxPoint node_pos, wxPoint target_pos) {
    if (!node)
        return nullptr;
 
    wxRect node_rect(node_pos.x - m_scaled.node_width / 2, node_pos.y, m_scaled.node_width, m_scaled.node_height);
 
    if (node_rect.Contains(target_pos)) {
        return node;
    }
 
    if (node->AreChildrenVisible() && node->GetChildCount() > 0) {
        int total_width = CalculateSubtreeWidth(node);
        wxCoord child_x = node_pos.x - total_width / 2;
        wxCoord child_y = node_pos.y + m_scaled.node_height + m_scaled.vertical_spacing;
 
        for (size_t i = 0; i < node->GetChildCount(); ++i) {
            EmberCore::ITreeNode *child = node->GetChild(i);
            if (child) {
                int subtree_width = CalculateSubtreeWidth(child);
                wxCoord center_x = child_x + subtree_width / 2;
 
                EmberCore::ITreeNode *found = FindNodeAtPosition(child, {center_x, child_y}, target_pos);
                if (found) {
                    return found;
                }
 
                child_x += subtree_width;
            }
        }
    }
 
    return nullptr;
}
 
EmberCore::ITreeNode *TreeCanvas::FindArrowAtPosition(const wxPoint &world_pos) const {
    const int hit_radius = 10;
    for (auto it = m_collapseArrows.rbegin(); it != m_collapseArrows.rend(); ++it) {
        wxCoord arrow_x = it->x;
        wxCoord arrow_y = it->y + m_scaled.node_height;
        int dx = world_pos.x - arrow_x;
        int dy = world_pos.y - arrow_y;
        if (dx * dx + dy * dy <= hit_radius * hit_radius)
            return it->node;
    }
    return nullptr;
}
 
wxPoint TreeCanvas::FindNodeWorldPosition(EmberCore::ITreeNode *target_node) {
    EmberCore::ITreeNode *root = GetEffectiveRoot();
    if (!target_node || !root)
        return {-1, -1};
 
    std::function<wxPoint(EmberCore::ITreeNode *, wxPoint, int)> findPosition =
        [&](EmberCore::ITreeNode *node, wxPoint node_pos, int level) -> wxPoint {
        if (!node)
            return {-1, -1};
 
        if (node == target_node || (node->GetId() == target_node->GetId() && node->GetName() == target_node->GetName()))
            return node_pos;
 
        if (node->AreChildrenVisible() && node->GetChildCount() > 0) {
            int total_width = CalculateSubtreeWidth(node);
            wxCoord child_x = node_pos.x - total_width / 2;
            wxCoord child_y = node_pos.y + m_scaled.node_height + m_scaled.vertical_spacing;
 
            for (size_t i = 0; i < node->GetChildCount(); ++i) {
                EmberCore::ITreeNode *child = node->GetChild(i);
                if (child) {
                    int subtree_width = CalculateSubtreeWidth(child);
                    wxCoord center_x = child_x + subtree_width / 2;
 
                    wxPoint found = findPosition(child, {center_x, child_y}, level + 1);
                    if (found.x != -1 && found.y != -1) {
                        return found;
                    }
 
                    child_x += subtree_width;
                }
            }
        }
 
        return {-1, -1};
    };
 
    wxPoint root_pos = CalculateRootPosition();
    return findPosition(root, root_pos, 0);
}
 
wxPoint TreeCanvas::ScreenToWorld(const wxPoint &screen_pos) const {
    return {static_cast<int>((screen_pos.x - m_viewOffset.x) / m_zoomFactor),
            static_cast<int>((screen_pos.y - m_viewOffset.y) / m_zoomFactor)};
}
 
wxPoint TreeCanvas::WorldToScreen(const wxPoint &world_pos) const {
    return {static_cast<int>(world_pos.x * m_zoomFactor + m_viewOffset.x),
            static_cast<int>(world_pos.y * m_zoomFactor + m_viewOffset.y)};
}
 
wxRect TreeCanvas::GetViewportBounds() const {
    wxSize panel_size = GetSize();
    wxPoint topLeft = ScreenToWorld({0, 0});
    wxPoint bottomRight = ScreenToWorld({panel_size.x, panel_size.y});
    return wxRect(topLeft.x, topLeft.y, bottomRight.x - topLeft.x, bottomRight.y - topLeft.y);
}
 
} // namespace EmberUI