TreeWidget.cpp

Go to the documentation of this file.

#include "Widgets/TreeWidget.h"
#include "Utils/AppPreferences.h"
#include "Utils/Logger.h"
#include <algorithm>
#include <cmath>
#include <wx/dcbuffer.h>
#include <wx/menu.h>
 
namespace EmberForge {
 
// Define static constexpr members for C++14 compatibility
constexpr double TreeWidget::MIN_ZOOM;
constexpr double TreeWidget::MAX_ZOOM;
 
// Event table
wxBEGIN_EVENT_TABLE(TreeWidget, wxScrolledWindow) EVT_PAINT(TreeWidget::OnPaint) EVT_SIZE(TreeWidget::OnSize)
    EVT_ERASE_BACKGROUND(TreeWidget::OnEraseBackground) EVT_LEFT_DOWN(TreeWidget::OnMouseDown)
        EVT_LEFT_UP(TreeWidget::OnMouseUp) EVT_MOTION(TreeWidget::OnMouseMove) EVT_MOUSEWHEEL(TreeWidget::OnMouseWheel)
            EVT_CONTEXT_MENU(TreeWidget::OnRightClick) EVT_KEY_DOWN(TreeWidget::OnKeyDown) EVT_CHAR(TreeWidget::OnChar)
                wxEND_EVENT_TABLE()
 
                    TreeWidget::TreeWidget(wxWindow *parent, std::shared_ptr<EmberCore::BehaviorTree> tree)
    : wxScrolledWindow(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxHSCROLL | wxVSCROLL | wxTAB_TRAVERSAL),
      behavior_tree_(tree), layout_algorithm_(LayoutAlgorithm::Vertical), interaction_mode_(InteractionMode::View),
      zoom_level_(1.0), view_offset_(0, 0), tree_size_(800, 600), node_render_style_(NodeWidget::RenderStyle::Normal),
      zoom_step_(0.1), mouse_wheel_sensitivity_(1.0), pan_sensitivity_(1.0), zoom_follows_cursor_(true),
      background_color_(wxColour(250, 250, 250)), grid_color_(wxColour(200, 200, 200)),
      connection_color_(wxColour(100, 100, 100)), connection_width_(2), grid_visible_(true), connections_visible_(true),
      is_dragging_(false), is_selecting_(false), node_spacing_x_(DEFAULT_NODE_SPACING_X),
      node_spacing_y_(DEFAULT_NODE_SPACING_Y), level_spacing_(DEFAULT_LEVEL_SPACING), tree_root_position_(50, 50),
      animation_timer_(nullptr) {
    InitializeWidget();
 
    if (behavior_tree_) {
        CreateNodeWidgets();
        RefreshLayout();
    }
}
 
TreeWidget::~TreeWidget() {
    if (animation_timer_) {
        animation_timer_->Stop();
        delete animation_timer_;
    }
    DestroyNodeWidgets();
}
 
void TreeWidget::SetBehaviorTree(std::shared_ptr<EmberCore::BehaviorTree> tree) {
    if (behavior_tree_ != tree) {
        DestroyNodeWidgets();
        behavior_tree_ = tree;
 
        if (behavior_tree_) {
            CreateNodeWidgets();
            RefreshLayout();
        }
 
        Refresh();
    }
}
 
void TreeWidget::SetLayoutAlgorithm(LayoutAlgorithm algorithm) {
    if (layout_algorithm_ != algorithm) {
        layout_algorithm_ = algorithm;
        RefreshLayout();
    }
}
 
void TreeWidget::RefreshLayout() {
    if (!behavior_tree_) {
        return;
    }
 
    switch (layout_algorithm_) {
    case LayoutAlgorithm::Vertical:
        CalculateVerticalLayout();
        break;
    case LayoutAlgorithm::Horizontal:
        CalculateHorizontalLayout();
        break;
    case LayoutAlgorithm::Radial:
        CalculateRadialLayout();
        break;
    case LayoutAlgorithm::Compact:
        CalculateCompactLayout();
        break;
    case LayoutAlgorithm::Manual:
        // Don't change positions in manual mode
        break;
    }
 
    PositionNodeWidgets();
    UpdateScrollbars();
    Refresh();
}
 
void TreeWidget::AutoFitLayout() {
    if (!behavior_tree_) {
        return;
    }
 
    // Calculate bounding box of all nodes
    wxRect boundingBox;
    bool first = true;
 
    for (const auto &pair : node_widgets_) {
        wxPoint pos = CalculateNodePosition(pair.first);
        wxSize size = pair.second->GetSize();
        wxRect nodeRect(pos, size);
 
        if (first) {
            boundingBox = nodeRect;
            first = false;
        } else {
            boundingBox = boundingBox.Union(nodeRect);
        }
    }
 
    if (!boundingBox.IsEmpty()) {
        // Add padding
        boundingBox.Inflate(50);
        tree_size_ = boundingBox.GetSize();
        tree_root_position_ = boundingBox.GetTopLeft();
    }
 
    RefreshLayout();
}
 
void TreeWidget::SetInteractionMode(InteractionMode mode) {
    interaction_mode_ = mode;
 
    // Update cursor based on mode
    switch (mode) {
    case InteractionMode::Edit:
        SetCursor(wxCursor(wxCURSOR_CROSS));
        break;
    case InteractionMode::Connect:
        SetCursor(wxCursor(wxCURSOR_HAND));
        break;
    default:
        SetCursor(wxCursor(wxCURSOR_ARROW));
        break;
    }
}
 
EmberForge::NodeWidget *TreeWidget::GetNodeWidget(EmberCore::Node *node) const {
    auto it = node_widgets_.find(node);
    if (it != node_widgets_.end()) {
        return it->second.get();
    }
    return nullptr;
}
 
std::vector<NodeWidget *> TreeWidget::GetAllNodeWidgets() const {
    std::vector<NodeWidget *> widgets;
    for (const auto &pair : node_widgets_) {
        widgets.push_back(pair.second.get());
    }
    return widgets;
}
 
std::vector<EmberForge::NodeWidget *> TreeWidget::GetSelectedNodeWidgets() const {
    std::vector<EmberForge::NodeWidget *> widgets;
    for (EmberCore::Node *node : selected_nodes_) {
        EmberForge::NodeWidget *widget = GetNodeWidget(node);
        if (widget) {
            widgets.push_back(widget);
        }
    }
    return widgets;
}
 
void TreeWidget::SelectNode(EmberCore::Node *node, bool add_to_selection) {
    if (!node)
        return;
 
    if (!add_to_selection) {
        ClearSelection();
    }
 
    auto it = std::find(selected_nodes_.begin(), selected_nodes_.end(), node);
    if (it == selected_nodes_.end()) {
        selected_nodes_.push_back(node);
        UpdateSelectionVisuals();
        NotifySelectionChange();
    }
}
 
void TreeWidget::DeselectNode(EmberCore::Node *node) {
    auto it = std::find(selected_nodes_.begin(), selected_nodes_.end(), node);
    if (it != selected_nodes_.end()) {
        selected_nodes_.erase(it);
        UpdateSelectionVisuals();
        NotifySelectionChange();
    }
}
 
void TreeWidget::ClearSelection() {
    if (!selected_nodes_.empty()) {
        selected_nodes_.clear();
        UpdateSelectionVisuals();
        NotifySelectionChange();
    }
}
 
void TreeWidget::SelectAll() {
    if (!behavior_tree_)
        return;
 
    selected_nodes_.clear();
    for (const auto &pair : node_widgets_) {
        selected_nodes_.push_back(pair.first);
    }
 
    UpdateSelectionVisuals();
    NotifySelectionChange();
}
 
EmberCore::Node *TreeWidget::GetSelectedNode() const { return selected_nodes_.empty() ? nullptr : selected_nodes_[0]; }
 
std::vector<EmberCore::Node *> TreeWidget::GetSelectedNodes() const { return selected_nodes_; }
 
void TreeWidget::ZoomIn() { SetZoomLevel(zoom_level_ + zoom_step_); }
 
void TreeWidget::ZoomOut() { SetZoomLevel(zoom_level_ - zoom_step_); }
 
void TreeWidget::ZoomToFit() {
    if (!behavior_tree_ || node_widgets_.empty()) {
        return;
    }
 
    // Calculate bounding box
    wxSize clientSize = GetClientSize();
    wxSize contentSize = CalculateTreeSize();
 
    if (contentSize.x > 0 && contentSize.y > 0) {
        double zoomX = static_cast<double>(clientSize.x) / contentSize.x;
        double zoomY = static_cast<double>(clientSize.y) / contentSize.y;
        double newZoom = std::min(zoomX, zoomY) * 0.9; // 90% to add margin
 
        SetZoomLevel(newZoom);
        CenterView();
    }
}
 
void TreeWidget::ZoomToSelection() {
    if (selected_nodes_.empty()) {
        return;
    }
 
    // Calculate bounding box of selected nodes
    wxRect boundingBox;
    bool first = true;
 
    for (EmberCore::Node *node : selected_nodes_) {
        EmberForge::NodeWidget *widget = GetNodeWidget(node);
        if (widget) {
            wxRect nodeRect = widget->GetRect();
            if (first) {
                boundingBox = nodeRect;
                first = false;
            } else {
                boundingBox = boundingBox.Union(nodeRect);
            }
        }
    }
 
    if (!boundingBox.IsEmpty()) {
        wxSize clientSize = GetClientSize();
        double zoomX = static_cast<double>(clientSize.x) / boundingBox.width;
        double zoomY = static_cast<double>(clientSize.y) / boundingBox.height;
        double newZoom = std::min(zoomX, zoomY) * 0.8;
 
        SetZoomLevel(newZoom);
 
        // Center on selection
        wxPoint center(boundingBox.x + boundingBox.width / 2, boundingBox.y + boundingBox.height / 2);
        view_offset_ = center - wxPoint(clientSize.x / 2, clientSize.y / 2);
        UpdateScrollbars();
    }
}
 
void TreeWidget::SetZoomLevel(double zoom) {
    zoom = std::max(MIN_ZOOM, std::min(MAX_ZOOM, zoom));
 
    if (std::abs(zoom_level_ - zoom) > 0.001) {
        zoom_level_ = zoom;
        RefreshLayout();
    }
}
 
void TreeWidget::CenterOnNode(EmberCore::Node *node) {
    NodeWidget *widget = GetNodeWidget(node);
    if (widget) {
        wxRect nodeRect = widget->GetRect();
        wxPoint nodeCenter(nodeRect.x + nodeRect.width / 2, nodeRect.y + nodeRect.height / 2);
        wxSize clientSize = GetClientSize();
        view_offset_ = nodeCenter - wxPoint(clientSize.x / 2, clientSize.y / 2);
        UpdateScrollbars();
        Refresh();
    }
}
 
void TreeWidget::CenterOnSelection() {
    if (!selected_nodes_.empty()) {
        CenterOnNode(selected_nodes_[0]);
    }
}
 
void TreeWidget::CenterView() {
    wxSize clientSize = GetClientSize();
    wxSize contentSize = CalculateTreeSize();
 
    view_offset_ = wxPoint((contentSize.x - clientSize.x) / 2, (contentSize.y - clientSize.y) / 2);
    UpdateScrollbars();
    Refresh();
}
 
bool TreeWidget::CanAddNode(EmberCore::Node *parent) const {
    return parent != nullptr && interaction_mode_ == InteractionMode::Edit;
}
 
bool TreeWidget::AddNode(std::unique_ptr<EmberCore::Node> node, EmberCore::Node *parent) {
    if (!CanAddNode(parent) || !node) {
        return false;
    }
 
    // Add to behavior tree
    EmberCore::Node *nodePtr = node.get();
    if (behavior_tree_->AddNode(std::move(node), parent)) {
        // Create widget for new node
        auto widget = CreateNodeWidget(nodePtr);
        if (widget) {
            node_widgets_[nodePtr] = std::move(widget);
            RefreshLayout();
 
            if (tree_change_callback_) {
                tree_change_callback_("node_added");
            }
 
            return true;
        }
    }
 
    return false;
}
 
bool TreeWidget::RemoveSelectedNodes() {
    if (selected_nodes_.empty() || interaction_mode_ != InteractionMode::Edit) {
        return false;
    }
 
    // Remove nodes from behavior tree
    for (EmberCore::Node *node : selected_nodes_) {
        behavior_tree_->RemoveNode(node->GetId());
 
        // Remove widget
        auto it = node_widgets_.find(node);
        if (it != node_widgets_.end()) {
            node_widgets_.erase(it);
        }
    }
 
    selected_nodes_.clear();
    RefreshLayout();
 
    if (tree_change_callback_) {
        tree_change_callback_("nodes_removed");
    }
 
    return true;
}
 
bool TreeWidget::DuplicateSelectedNodes() {
    // Placeholder implementation
    return false;
}
 
bool TreeWidget::CanMoveNode(EmberCore::Node *node, EmberCore::Node *new_parent) const {
    return node && new_parent && interaction_mode_ == InteractionMode::Edit;
}
 
bool TreeWidget::MoveNode(EmberCore::Node *node, EmberCore::Node *new_parent) {
    if (!CanMoveNode(node, new_parent)) {
        return false;
    }
 
    if (behavior_tree_->MoveNode(node->GetId(), new_parent)) {
        RefreshLayout();
 
        if (tree_change_callback_) {
            tree_change_callback_("node_moved");
        }
 
        return true;
    }
 
    return false;
}
 
void TreeWidget::SetNodeRenderStyle(NodeWidget::RenderStyle style) {
    if (node_render_style_ != style) {
        node_render_style_ = style;
 
        for (auto &pair : node_widgets_) {
            pair.second->SetRenderStyle(style);
        }
 
        Refresh();
    }
}
 
void TreeWidget::SetConnectionStyle(int line_width, const wxColour &color) {
    connection_width_ = line_width;
    connection_color_ = color;
    Refresh();
}
 
void TreeWidget::SetBackgroundColor(const wxColour &color) {
    background_color_ = color;
    Refresh();
}
 
void TreeWidget::SetGridVisible(bool visible) {
    grid_visible_ = visible;
    Refresh();
}
 
void TreeWidget::SetConnectionsVisible(bool visible) {
    connections_visible_ = visible;
    Refresh();
}
 
void TreeWidget::AnimateToNode(EmberCore::Node *node) {
    // Placeholder for animation implementation
    CenterOnNode(node);
}
 
void TreeWidget::HighlightExecutionPath(const std::vector<EmberCore::Node *> &path) {
    highlighted_path_ = path;
 
    // Update highlighting for all nodes
    for (auto &pair : node_widgets_) {
        bool highlighted = std::find(path.begin(), path.end(), pair.first) != path.end();
        pair.second->SetHighlighted(highlighted);
    }
 
    Refresh();
}
 
void TreeWidget::ClearHighlights() {
    highlighted_path_.clear();
 
    for (auto &pair : node_widgets_) {
        pair.second->SetHighlighted(false);
    }
 
    Refresh();
}
 
bool TreeWidget::SaveLayout(const wxString &filename) const {
    // Placeholder implementation
    return false;
}
 
bool TreeWidget::LoadLayout(const wxString &filename) {
    // Placeholder implementation
    return false;
}
 
wxBitmap TreeWidget::ExportAsImage(const wxSize &size) const {
    wxSize exportSize = size.IsFullySpecified() ? size : GetSize();
    wxBitmap bitmap(exportSize);
    wxMemoryDC dc(bitmap);
 
    // Draw the tree to the bitmap
    dc.SetBackground(wxBrush(background_color_));
    dc.Clear();
 
    // TODO: Implement drawing logic
 
    return bitmap;
}
 
// Protected rendering methods
void TreeWidget::OnPaint(wxPaintEvent &event) {
    wxAutoBufferedPaintDC dc(this);
    DoPrepareDC(dc);
 
    // Scale for zoom
    dc.SetUserScale(zoom_level_, zoom_level_);
 
    DrawBackground(dc);
 
    if (grid_visible_) {
        DrawGrid(dc);
    }
 
    if (connections_visible_) {
        DrawConnections(dc);
    }
 
    if (is_selecting_) {
        DrawSelectionRect(dc);
    }
}
 
void TreeWidget::OnSize(wxSizeEvent &event) {
    UpdateScrollbars();
    event.Skip();
}
 
void TreeWidget::OnEraseBackground(wxEraseEvent &event) {
    // Prevent flicker
}
 
// Event handlers continue...
void TreeWidget::OnMouseDown(wxMouseEvent &event) {
    SetFocus();
 
    wxPoint logicalPos = TreeToScreen(event.GetPosition());
    NodeWidget *hitNode = HitTestNode(logicalPos);
 
    if (hitNode) {
        EmberCore::Node *node = hitNode->GetNode();
        bool addToSelection = event.ControlDown();
 
        if (!addToSelection ||
            std::find(selected_nodes_.begin(), selected_nodes_.end(), node) == selected_nodes_.end()) {
            SelectNode(node, addToSelection);
        }
 
        drag_start_pos_ = event.GetPosition();
        is_dragging_ = true;
    } else {
        // Start selection rectangle
        if (!event.ControlDown()) {
            ClearSelection();
        }
 
        selection_start_pos_ = event.GetPosition();
        is_selecting_ = true;
        CaptureMouse();
    }
 
    event.Skip();
}
 
void TreeWidget::OnMouseUp(wxMouseEvent &event) {
    if (HasCapture()) {
        ReleaseMouse();
    }
 
    if (is_selecting_) {
        // Finish selection rectangle
        wxRect selectionRect(selection_start_pos_, event.GetPosition());
        // Normalize rectangle
 
        // Select nodes in rectangle
        for (const auto &pair : node_widgets_) {
            wxRect nodeRect = pair.second->GetRect();
            if (selectionRect.Intersects(nodeRect)) {
                SelectNode(pair.first, true);
            }
        }
 
        is_selecting_ = false;
        Refresh();
    }
 
    is_dragging_ = false;
    event.Skip();
}
 
void TreeWidget::OnMouseMove(wxMouseEvent &event) {
    if (is_selecting_) {
        selection_rect_ = wxRect(selection_start_pos_, event.GetPosition());
        Refresh();
    }
 
    event.Skip();
}
 
void TreeWidget::OnMouseWheel(wxMouseEvent &event) {
    if (event.ControlDown()) {
        // Zoom with preferences applied
        double delta = (event.GetWheelRotation() > 0 ? zoom_step_ : -zoom_step_) * mouse_wheel_sensitivity_;
 
        if (zoom_follows_cursor_) {
            // Zoom towards cursor position
            wxPoint mousePos = event.GetPosition();
            wxPoint scrollPos = GetViewStart();
            int pixelsPerUnitX, pixelsPerUnitY;
            GetScrollPixelsPerUnit(&pixelsPerUnitX, &pixelsPerUnitY);
 
            // Convert mouse position to world coordinates before zoom
            double worldX = (mousePos.x + scrollPos.x * pixelsPerUnitX) / zoom_level_;
            double worldY = (mousePos.y + scrollPos.y * pixelsPerUnitY) / zoom_level_;
 
            double oldZoom = zoom_level_;
            SetZoomLevel(zoom_level_ + delta);
 
            // Adjust scroll to keep world point under cursor
            if (std::abs(zoom_level_ - oldZoom) > 0.001) {
                int newScrollX = static_cast<int>((worldX * zoom_level_ - mousePos.x) / pixelsPerUnitX);
                int newScrollY = static_cast<int>((worldY * zoom_level_ - mousePos.y) / pixelsPerUnitY);
                Scroll(newScrollX, newScrollY);
            }
        } else {
            // Zoom towards center
            SetZoomLevel(zoom_level_ + delta);
        }
    } else {
        // Scroll
        event.Skip();
    }
}
 
void TreeWidget::OnRightClick(wxContextMenuEvent &event) { ShowContextMenu(event.GetPosition()); }
 
void TreeWidget::OnKeyDown(wxKeyEvent &event) {
    switch (event.GetKeyCode()) {
    case WXK_DELETE:
        RemoveSelectedNodes();
        break;
    case WXK_CONTROL_A:
        SelectAll();
        break;
    case WXK_ESCAPE:
        ClearSelection();
        break;
    default:
        event.Skip();
        break;
    }
}
 
void TreeWidget::OnChar(wxKeyEvent &event) { event.Skip(); }
 
// Layout calculation methods (simplified implementations)
void TreeWidget::CalculateVerticalLayout() {
    if (!behavior_tree_ || !behavior_tree_->GetRootNode()) {
        return;
    }
 
    // Simple vertical tree layout
    // This is a basic implementation - can be enhanced
    EmberCore::Node *root = behavior_tree_->GetRootNode();
    LayoutNodeVertical(root, tree_root_position_.x + tree_size_.x / 2, tree_root_position_.y, 0);
}
 
void TreeWidget::CalculateHorizontalLayout() {
    // Placeholder implementation
    CalculateVerticalLayout(); // Use vertical for now
}
 
void TreeWidget::CalculateRadialLayout() {
    // Placeholder implementation
    CalculateVerticalLayout(); // Use vertical for now
}
 
void TreeWidget::CalculateCompactLayout() {
    // Placeholder implementation
    CalculateVerticalLayout(); // Use vertical for now
}
 
// Helper method for vertical layout
void TreeWidget::LayoutNodeVertical(EmberCore::Node *node, int x, int y, int level) {
    if (!node)
        return;
 
    // Store position for this node
    node_positions_[node] = wxPoint(x, y);
 
    // Layout children
    std::vector<EmberCore::Node *> children = node->GetAllChildren();
    if (!children.empty()) {
        int childY = y + level_spacing_;
        int totalWidth = (children.size() - 1) * node_spacing_x_;
        int startX = x - totalWidth / 2;
 
        for (size_t i = 0; i < children.size(); ++i) {
            int childX = startX + i * node_spacing_x_;
            LayoutNodeVertical(children[i], childX, childY, level + 1);
        }
    }
}
 
// Drawing helper methods
void TreeWidget::DrawBackground(wxDC &dc) {
    wxRect clientRect = GetClientRect();
    dc.SetBrush(wxBrush(background_color_));
    dc.SetPen(wxPen(background_color_));
    dc.DrawRectangle(clientRect);
}
 
void TreeWidget::DrawGrid(wxDC &dc) {
    wxRect clientRect = GetClientRect();
 
    // Get grid background color from preferences
    auto &prefs = EmberForge::AppPreferencesManager::GetInstance().GetPreferences();
    const auto &mainPanelSettings = prefs.GetMainPanelSettings();
    wxColour gridBgColor(mainPanelSettings.gridBackgroundColor.r, mainPanelSettings.gridBackgroundColor.g,
                         mainPanelSettings.gridBackgroundColor.b);
 
    // Draw grid background
    dc.SetBrush(wxBrush(gridBgColor));
    dc.SetPen(*wxTRANSPARENT_PEN);
    dc.DrawRectangle(clientRect);
 
    // Draw grid lines
    dc.SetPen(wxPen(grid_color_, 1, wxPENSTYLE_DOT));
    dc.SetBrush(*wxTRANSPARENT_BRUSH);
 
    // Draw vertical lines
    for (int x = 0; x < clientRect.width; x += GRID_SIZE) {
        dc.DrawLine(x, 0, x, clientRect.height);
    }
 
    // Draw horizontal lines
    for (int y = 0; y < clientRect.height; y += GRID_SIZE) {
        dc.DrawLine(0, y, clientRect.width, y);
    }
}
 
void TreeWidget::DrawConnections(wxDC &dc) {
    if (!behavior_tree_)
        return;
 
    dc.SetPen(wxPen(connection_color_, connection_width_));
 
    for (const auto &pair : node_widgets_) {
        EmberCore::Node *node = pair.first;
        EmberForge::NodeWidget *parentWidget = pair.second.get();
 
        // Draw connections to children
        for (EmberCore::Node *child : node->GetAllChildren()) {
            NodeWidget *childWidget = GetNodeWidget(child);
            if (childWidget) {
                DrawConnection(dc, parentWidget, childWidget);
            }
        }
    }
}
 
void TreeWidget::DrawConnection(wxDC &dc, NodeWidget *parent, NodeWidget *child) {
    if (!parent || !child)
        return;
 
    wxRect parentRect = parent->GetRect();
    wxRect childRect = child->GetRect();
    wxPoint parentCenter(parentRect.x + parentRect.width / 2, parentRect.y + parentRect.height / 2);
    wxPoint childCenter(childRect.x + childRect.width / 2, childRect.y + childRect.height / 2);
 
    // Draw simple line
    dc.DrawLine(parentCenter, childCenter);
}
 
void TreeWidget::DrawSelectionRect(wxDC &dc) {
    if (is_selecting_) {
        dc.SetPen(wxPen(wxColour(0, 0, 255), 1, wxPENSTYLE_DOT));
        dc.SetBrush(wxBrush(wxColour(0, 0, 255, 50)));
        dc.DrawRectangle(selection_rect_);
    }
}
 
// Node widget management
void TreeWidget::CreateNodeWidgets() {
    if (!behavior_tree_)
        return;
 
    std::vector<EmberCore::Node *> allNodes = behavior_tree_->GetAllNodes();
    for (EmberCore::Node *node : allNodes) {
        auto widget = CreateNodeWidget(node);
        if (widget) {
            node_widgets_[node] = std::move(widget);
        }
    }
}
 
void TreeWidget::UpdateNodeWidgets() {
    for (auto &pair : node_widgets_) {
        pair.second->UpdateFromNode();
    }
}
 
void TreeWidget::DestroyNodeWidgets() { node_widgets_.clear(); }
 
std::unique_ptr<EmberForge::NodeWidget> TreeWidget::CreateNodeWidget(EmberCore::Node *node) {
    if (!node)
        return nullptr;
 
    auto widget = std::make_unique<NodeWidget>(this, node, node_render_style_);
 
    // Set up callbacks
    widget->SetNodeClickCallback([this](EmberForge::NodeWidget *w, EmberCore::Node *n) { OnNodeClicked(w, n); });
 
    widget->SetNodeDoubleClickCallback(
        [this](EmberForge::NodeWidget *w, EmberCore::Node *n) { OnNodeDoubleClicked(w, n); });
 
    widget->SetNodeDragCallback([this](NodeWidget *w, const wxPoint &delta) { OnNodeDragged(w, delta); });
 
    widget->SetNodeEditCallback([this](NodeWidget *w, const wxString &newName) { OnNodeEdited(w, newName); });
 
    return widget;
}
 
// Hit testing
NodeWidget *TreeWidget::HitTestNode(const wxPoint &point) const {
    for (const auto &pair : node_widgets_) {
        if (pair.second->GetRect().Contains(point)) {
            return pair.second.get();
        }
    }
    return nullptr;
}
 
EmberCore::Node *TreeWidget::HitTestConnection(const wxPoint &point) const {
    // Placeholder implementation
    return nullptr;
}
 
// Selection helpers
void TreeWidget::UpdateSelectionVisuals() {
    for (auto &pair : node_widgets_) {
        bool selected = std::find(selected_nodes_.begin(), selected_nodes_.end(), pair.first) != selected_nodes_.end();
        pair.second->SetSelected(selected);
    }
    Refresh();
}
 
void TreeWidget::NotifySelectionChange() {
    if (selection_callback_) {
        selection_callback_(selected_nodes_);
    }
}
 
// Layout helpers
wxSize TreeWidget::CalculateTreeSize() const { return tree_size_; }
 
wxPoint TreeWidget::CalculateNodePosition(EmberCore::Node *node) const {
    auto it = node_positions_.find(node);
    if (it != node_positions_.end()) {
        return it->second;
    }
    return wxPoint(0, 0);
}
 
void TreeWidget::PositionNodeWidgets() {
    for (auto &pair : node_widgets_) {
        EmberCore::Node *node = pair.first;
        EmberForge::NodeWidget *widget = pair.second.get();
 
        wxPoint pos = CalculateNodePosition(node);
        wxSize size = widget->GetPreferredSize();
 
        // Apply zoom
        pos.x = static_cast<int>(pos.x * zoom_level_);
        pos.y = static_cast<int>(pos.y * zoom_level_);
        size.x = static_cast<int>(size.x * zoom_level_);
        size.y = static_cast<int>(size.y * zoom_level_);
 
        widget->SetPosition(pos);
        widget->SetSize(size);
    }
}
 
void TreeWidget::UpdateScrollbars() {
    wxSize virtualSize = CalculateTreeSize();
 
    virtualSize.x = static_cast<int>(virtualSize.x * zoom_level_);
    virtualSize.y = static_cast<int>(virtualSize.y * zoom_level_);
 
    SetVirtualSize(virtualSize);
    SetScrollRate(20, 20);
}
 
// Coordinate conversion
wxPoint TreeWidget::TreeToScreen(const wxPoint &tree_point) const {
    wxPoint screenPoint = tree_point;
    screenPoint.x = static_cast<int>(screenPoint.x * zoom_level_) - view_offset_.x;
    screenPoint.y = static_cast<int>(screenPoint.y * zoom_level_) - view_offset_.y;
    return screenPoint;
}
 
wxPoint TreeWidget::ScreenToTree(const wxPoint &screen_point) const {
    wxPoint treePoint = screen_point;
    treePoint.x = static_cast<int>((treePoint.x + view_offset_.x) / zoom_level_);
    treePoint.y = static_cast<int>((treePoint.y + view_offset_.y) / zoom_level_);
    return treePoint;
}
 
wxRect TreeWidget::TreeToScreen(const wxRect &tree_rect) const {
    wxPoint topLeft = TreeToScreen(tree_rect.GetTopLeft());
    wxPoint bottomRight = TreeToScreen(tree_rect.GetBottomRight());
    return wxRect(topLeft, bottomRight);
}
 
wxRect TreeWidget::ScreenToTree(const wxRect &screen_rect) const {
    wxPoint topLeft = ScreenToTree(screen_rect.GetTopLeft());
    wxPoint bottomRight = ScreenToTree(screen_rect.GetBottomRight());
    return wxRect(topLeft, bottomRight);
}
 
// Private helper methods
void TreeWidget::InitializeWidget() {
    SetBackgroundStyle(wxBG_STYLE_CUSTOM);
    SetupEventHandlers();
    LoadPreferences();
    UpdateViewSize();
}
 
void TreeWidget::SetupEventHandlers() {
    // Event handlers are set up in the event table
}
 
void TreeWidget::UpdateViewSize() { UpdateScrollbars(); }
 
void TreeWidget::ShowContextMenu(const wxPoint &position) {
    wxMenu menu;
 
    if (!selected_nodes_.empty()) {
        menu.Append(wxID_ANY, "Delete Selected", "Delete selected nodes");
        menu.Append(wxID_ANY, "Duplicate Selected", "Duplicate selected nodes");
        menu.AppendSeparator();
    }
 
    menu.Append(wxID_ANY, "Add Node", "Add a new node");
    menu.AppendSeparator();
    menu.Append(wxID_ANY, "Zoom to Fit", "Zoom to fit all nodes");
    menu.Append(wxID_ANY, "Reset Zoom", "Reset zoom to 100%");
 
    PopupMenu(&menu, position);
}
 
// Node widget event handlers
void TreeWidget::OnNodeClicked(EmberForge::NodeWidget *widget, EmberCore::Node *node) {
    // Already handled in mouse events
}
 
void TreeWidget::OnNodeDoubleClicked(EmberForge::NodeWidget *widget, EmberCore::Node *node) {
    if (edit_callback_) {
        edit_callback_(node, "name", node->GetName());
    }
}
 
void TreeWidget::OnNodeDragged(NodeWidget *widget, const wxPoint &delta) {
    if (layout_algorithm_ == LayoutAlgorithm::Manual) {
        // Update position for manual layout
        wxPoint currentPos = widget->GetPosition();
        widget->SetPosition(currentPos + delta);
    }
}
 
void TreeWidget::OnNodeEdited(EmberForge::NodeWidget *widget, const wxString &new_name) {
    EmberCore::Node *node = widget->GetNode();
    if (node && edit_callback_) {
        edit_callback_(node, "name", new_name);
    }
}
 
void TreeWidget::LoadPreferences() {
    auto &prefs = EmberForge::AppPreferencesManager::GetInstance().GetPreferences();
    const auto &btViewSettings = prefs.GetBehaviorTreeViewSettings();
 
    // Load zoom/pan preferences
    zoom_step_ = btViewSettings.zoomStepSize;
    mouse_wheel_sensitivity_ = btViewSettings.mouseWheelSensitivity;
    pan_sensitivity_ = btViewSettings.panSensitivity;
    zoom_follows_cursor_ = btViewSettings.zoomFollowsCursor;
 
    LOG_INFO("TreeWidget",
             wxString::Format(
                 "Loaded preferences: zoom_step=%.2f, wheel_sens=%.2f, pan_sens=%.2f, zoom_follows_cursor=%s",
                 zoom_step_, mouse_wheel_sensitivity_, pan_sensitivity_, zoom_follows_cursor_ ? "true" : "false")
                 .ToStdString());
}
 
} // namespace EmberForge