NodeWidget.cpp

Go to the documentation of this file.

#include "Widgets/NodeWidget.h"
#include "Utils/AppPreferences.h"
#include "Utils/Logger.h"
#include <wx/bitmap.h>
#include <wx/dc.h>
#include <wx/menu.h>
#include <wx/textctrl.h>
#include <wx/timer.h>
 
namespace EmberForge {
 
// Event table
wxBEGIN_EVENT_TABLE(EmberForge::NodeWidget, wxPanel) EVT_PAINT(EmberForge::NodeWidget::OnPaint)
    EVT_SIZE(EmberForge::NodeWidget::OnSize) EVT_ERASE_BACKGROUND(EmberForge::NodeWidget::OnEraseBackground)
        EVT_ENTER_WINDOW(EmberForge::NodeWidget::OnMouseEnter) EVT_LEAVE_WINDOW(EmberForge::NodeWidget::OnMouseLeave)
            EVT_LEFT_DOWN(EmberForge::NodeWidget::OnMouseDown) EVT_LEFT_UP(EmberForge::NodeWidget::OnMouseUp)
                EVT_MOTION(EmberForge::NodeWidget::OnMouseMove)
                    EVT_LEFT_DCLICK(EmberForge::NodeWidget::OnMouseDoubleClick)
                        EVT_CONTEXT_MENU(EmberForge::NodeWidget::OnRightClick)
                            EVT_KEY_DOWN(EmberForge::NodeWidget::OnKeyDown) EVT_CHAR(EmberForge::NodeWidget::OnChar)
                                EVT_SET_FOCUS(EmberForge::NodeWidget::OnSetFocus)
                                    EVT_KILL_FOCUS(EmberForge::NodeWidget::OnKillFocus)
                                        EVT_TIMER(wxID_ANY,
                                                  EmberForge::NodeWidget::OnAnimationTimer) wxEND_EVENT_TABLE()
 
                                            EmberForge::NodeWidget::NodeWidget(wxWindow *parent, EmberCore::Node *node,
                                                                               RenderStyle style)
    : wxPanel(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL | wxBORDER_NONE), node_(node),
      render_style_(style), interaction_state_(InteractionState::Normal), custom_size_(wxDefaultSize),
      is_draggable_(true), is_highlighted_(false), animation_timer_(nullptr), animation_phase_(0.0),
      is_animating_(false), edit_control_(nullptr) {
    InitializeWidget();
}
 
EmberForge::NodeWidget::~NodeWidget() {
    if (animation_timer_) {
        animation_timer_->Stop();
        delete animation_timer_;
    }
    DestroyEditControl();
}
 
void EmberForge::NodeWidget::SetNode(EmberCore::Node *node) {
    node_ = node;
    UpdateFromNode();
    Refresh();
}
 
void EmberForge::NodeWidget::SetRenderStyle(RenderStyle style) {
    render_style_ = style;
    Refresh();
}
 
void EmberForge::NodeWidget::SetInteractionState(InteractionState state) {
    if (interaction_state_ != state) {
        interaction_state_ = state;
        UpdateColors();
        Refresh();
    }
}
 
void EmberForge::NodeWidget::SetSelected(bool selected) {
    SetInteractionState(selected ? InteractionState::Selected : InteractionState::Normal);
}
 
void EmberForge::NodeWidget::StartEditing() {
    if (!node_ || interaction_state_ == InteractionState::Editing) {
        return;
    }
 
    SetInteractionState(InteractionState::Editing);
    CreateEditControl();
}
 
void EmberForge::NodeWidget::StopEditing(bool save_changes) {
    if (interaction_state_ != InteractionState::Editing || !edit_control_) {
        return;
    }
 
    if (save_changes && node_) {
        wxString newName = edit_control_->GetValue();
        if (newName != original_name_ && edit_callback_) {
            edit_callback_(this, newName);
        }
    }
 
    DestroyEditControl();
    SetInteractionState(InteractionState::Normal);
    Refresh();
}
 
void EmberForge::NodeWidget::UpdateFromNode() {
    if (!node_) {
        return;
    }
 
    // Update colors based on node state
    UpdateColors();
 
    // Update size if needed
    wxSize preferredSize = GetPreferredSize();
    if (GetSize() != preferredSize) {
        SetSize(preferredSize);
    }
}
 
void EmberForge::NodeWidget::SyncVisualState() { UpdateFromNode(); }
 
wxSize EmberForge::NodeWidget::GetPreferredSize() const {
    if (custom_size_ != wxDefaultSize) {
        return custom_size_;
    }
 
    wxSize size(MIN_WIDTH, MIN_HEIGHT);
 
    if (node_) {
        wxString text = GetDisplayText();
        if (!text.IsEmpty()) {
            wxClientDC dc(const_cast<EmberForge::NodeWidget *>(this));
            dc.SetFont(node_font_);
            wxSize textSize = dc.GetTextExtent(text);
 
            size.x = std::max(size.x, textSize.x + 2 * PADDING + ICON_SIZE + PADDING);
            size.y = std::max(size.y, textSize.y + 2 * PADDING);
        }
    }
 
    return size;
}
 
wxSize EmberForge::NodeWidget::CalculateMinSize() const { return wxSize(MIN_WIDTH, MIN_HEIGHT); }
 
void EmberForge::NodeWidget::SetCustomSize(const wxSize &size) {
    custom_size_ = size;
    SetSize(size);
}
 
void EmberForge::NodeWidget::SetNodeColors(const wxColour &background, const wxColour &border, const wxColour &text) {
    background_color_ = background;
    border_color_ = border;
    text_color_ = text;
    Refresh();
}
 
void EmberForge::NodeWidget::SetNodeFont(const wxFont &font) {
    node_font_ = font;
    Refresh();
}
 
void EmberForge::NodeWidget::ResetToDefaultAppearance() {
    background_color_ = GetBackgroundColor();
    border_color_ = GetBorderColor();
    text_color_ = GetTextColor();
    node_font_ = GetFont();
    Refresh();
}
 
void EmberForge::NodeWidget::StartPulseAnimation() {
    if (!animation_timer_) {
        animation_timer_ = new wxTimer(this);
    }
 
    is_animating_ = true;
    animation_phase_ = 0.0;
    animation_timer_->Start(50); // 20 FPS
}
 
void EmberForge::NodeWidget::StopPulseAnimation() {
    if (animation_timer_) {
        animation_timer_->Stop();
    }
    is_animating_ = false;
    Refresh();
}
 
void EmberForge::NodeWidget::SetHighlighted(bool highlighted) {
    if (is_highlighted_ != highlighted) {
        is_highlighted_ = highlighted;
        UpdateColors();
        Refresh();
    }
}
 
// Protected event handlers
void EmberForge::NodeWidget::OnPaint(wxPaintEvent &event) {
    wxPaintDC dc(this);
 
    // Clear background
    dc.SetBackground(wxBrush(GetBackgroundColor()));
    dc.Clear();
 
    wxRect clientRect = GetClientRect();
 
    // Draw node background
    DrawNodeBackground(dc, clientRect);
 
    // Draw node border
    DrawNodeBorder(dc, clientRect);
 
    // Draw content based on render style
    switch (render_style_) {
    case RenderStyle::Compact:
        DrawNodeText(dc, GetTextRect());
        break;
    case RenderStyle::Normal:
        DrawNodeIcon(dc, GetIconRect());
        DrawNodeText(dc, GetTextRect());
        break;
    case RenderStyle::Detailed:
        DrawNodeIcon(dc, GetIconRect());
        DrawNodeText(dc, GetTextRect());
        DrawNodeStatus(dc, GetStatusRect());
        break;
    case RenderStyle::Debug:
        DrawNodeIcon(dc, GetIconRect());
        DrawNodeText(dc, GetTextRect());
        DrawNodeStatus(dc, GetStatusRect());
        DrawConnectionPoints(dc);
        break;
    }
}
 
void EmberForge::NodeWidget::OnSize(wxSizeEvent &event) {
    // Reposition edit control if active
    if (edit_control_) {
        edit_control_->SetSize(GetTextRect());
    }
 
    event.Skip();
}
 
void EmberForge::NodeWidget::OnEraseBackground(wxEraseEvent &event) {
    // Prevent flicker by not erasing background
}
 
void EmberForge::NodeWidget::OnMouseEnter(wxMouseEvent &event) {
    if (interaction_state_ == InteractionState::Normal) {
        SetInteractionState(InteractionState::Hovered);
    }
    event.Skip();
}
 
void EmberForge::NodeWidget::OnMouseLeave(wxMouseEvent &event) {
    if (interaction_state_ == InteractionState::Hovered) {
        SetInteractionState(InteractionState::Normal);
    }
    event.Skip();
}
 
void EmberForge::NodeWidget::OnMouseDown(wxMouseEvent &event) {
    if (event.LeftDown()) {
        drag_start_pos_ = event.GetPosition();
        last_mouse_pos_ = event.GetPosition();
 
        if (click_callback_) {
            click_callback_(this, node_);
        }
 
        if (!IsSelected()) {
            SetSelected(true);
        }
 
        CaptureMouse();
    }
    event.Skip();
}
 
void EmberForge::NodeWidget::OnMouseUp(wxMouseEvent &event) {
    if (HasCapture()) {
        ReleaseMouse();
    }
 
    if (interaction_state_ == InteractionState::Dragging) {
        SetInteractionState(InteractionState::Selected);
    }
 
    event.Skip();
}
 
void EmberForge::NodeWidget::OnMouseMove(wxMouseEvent &event) {
    if (event.Dragging() && HasCapture() && is_draggable_) {
        wxPoint currentPos = event.GetPosition();
        wxPoint delta = currentPos - last_mouse_pos_;
 
        if (interaction_state_ != InteractionState::Dragging) {
            SetInteractionState(InteractionState::Dragging);
        }
 
        if (drag_callback_) {
            drag_callback_(this, delta);
        }
 
        last_mouse_pos_ = currentPos;
    }
    event.Skip();
}
 
void EmberForge::NodeWidget::OnMouseDoubleClick(wxMouseEvent &event) {
    if (double_click_callback_) {
        double_click_callback_(this, node_);
    } else {
        // Default behavior: start editing
        StartEditing();
    }
    event.Skip();
}
 
void EmberForge::NodeWidget::OnRightClick(wxContextMenuEvent &event) { ShowContextMenu(event.GetPosition()); }
 
void EmberForge::NodeWidget::OnKeyDown(wxKeyEvent &event) {
    int keyCode = event.GetKeyCode();
 
    switch (keyCode) {
    case WXK_F2:
        StartEditing();
        break;
    case WXK_ESCAPE:
        if (interaction_state_ == InteractionState::Editing) {
            StopEditing(false);
        }
        break;
    case WXK_RETURN:
        if (interaction_state_ == InteractionState::Editing) {
            StopEditing(true);
        }
        break;
    default:
        event.Skip();
        break;
    }
}
 
void EmberForge::NodeWidget::OnChar(wxKeyEvent &event) { event.Skip(); }
 
void EmberForge::NodeWidget::OnSetFocus(wxFocusEvent &event) {
    Refresh();
    event.Skip();
}
 
void EmberForge::NodeWidget::OnKillFocus(wxFocusEvent &event) {
    if (interaction_state_ == InteractionState::Editing) {
        StopEditing(true);
    }
    Refresh();
    event.Skip();
}
 
// Drawing helpers
void EmberForge::NodeWidget::DrawNodeBackground(wxDC &dc, const wxRect &rect) {
    wxColour bgColor = GetBackgroundColor();
 
    if (is_animating_) {
        // Pulse effect
        int alpha = 128 + static_cast<int>(127 * std::sin(animation_phase_));
        bgColor = wxColour(bgColor.Red(), bgColor.Green(), bgColor.Blue(), alpha);
    }
 
    dc.SetBrush(wxBrush(bgColor));
    dc.SetPen(wxPen(bgColor));
    dc.DrawRoundedRectangle(rect, 4);
}
 
void EmberForge::NodeWidget::DrawNodeBorder(wxDC &dc, const wxRect &rect) {
    wxColour borderColor = GetBorderColor();
 
    dc.SetBrush(wxNullBrush);
    dc.SetPen(wxPen(borderColor, BORDER_WIDTH));
    dc.DrawRoundedRectangle(rect, 4);
}
 
void EmberForge::NodeWidget::DrawNodeIcon(wxDC &dc, const wxRect &icon_rect) {
    wxBitmap icon = GetNodeIcon();
    if (icon.IsOk()) {
        dc.DrawBitmap(icon, icon_rect.GetTopLeft());
    }
}
 
void EmberForge::NodeWidget::DrawNodeText(wxDC &dc, const wxRect &text_rect) {
    wxString text = GetDisplayText();
    if (!text.IsEmpty()) {
        dc.SetFont(node_font_);
        dc.SetTextForeground(GetTextColor());
        dc.DrawLabel(text, text_rect, wxALIGN_CENTER);
    }
}
 
void EmberForge::NodeWidget::DrawNodeStatus(wxDC &dc, const wxRect &status_rect) {
    if (!node_)
        return;
 
    // Draw status indicator based on node execution state
    EmberCore::Node::Status status = node_->GetStatus();
    wxColour statusColor;
 
    switch (status) {
    case EmberCore::Node::Status::Success:
        statusColor = wxColour(0, 255, 0); // Green
        break;
    case EmberCore::Node::Status::Failure:
        statusColor = wxColour(255, 0, 0); // Red
        break;
    case EmberCore::Node::Status::Running:
        statusColor = wxColour(255, 255, 0); // Yellow
        break;
    default:
        statusColor = wxColour(128, 128, 128); // Gray
        break;
    }
 
    dc.SetBrush(wxBrush(statusColor));
    dc.SetPen(wxPen(statusColor));
    wxPoint center(status_rect.x + status_rect.width / 2, status_rect.y + status_rect.height / 2);
    dc.DrawCircle(center, 4);
}
 
void EmberForge::NodeWidget::DrawConnectionPoints(wxDC &dc) {
    std::vector<wxPoint> points = GetConnectionPoints();
 
    dc.SetBrush(wxBrush(wxColour(0, 0, 255))); // Blue
    dc.SetPen(wxPen(wxColour(0, 0, 255)));
 
    for (const wxPoint &point : points) {
        dc.DrawCircle(point, 3);
    }
}
 
// Layout helpers
wxRect EmberForge::NodeWidget::GetContentRect() const {
    wxRect rect = GetClientRect();
    rect.Deflate(PADDING);
    return rect;
}
 
wxRect EmberForge::NodeWidget::GetIconRect() const {
    if (render_style_ == RenderStyle::Compact) {
        return wxRect();
    }
 
    wxRect contentRect = GetContentRect();
    return wxRect(contentRect.x, contentRect.y, ICON_SIZE, ICON_SIZE);
}
 
wxRect EmberForge::NodeWidget::GetTextRect() const {
    wxRect contentRect = GetContentRect();
 
    if (render_style_ == RenderStyle::Compact) {
        return contentRect;
    }
 
    wxRect iconRect = GetIconRect();
    return wxRect(iconRect.GetRight() + PADDING, contentRect.y, contentRect.width - iconRect.width - PADDING,
                  contentRect.height);
}
 
wxRect EmberForge::NodeWidget::GetStatusRect() const {
    if (render_style_ != RenderStyle::Detailed && render_style_ != RenderStyle::Debug) {
        return wxRect();
    }
 
    wxRect contentRect = GetContentRect();
    return wxRect(contentRect.GetRight() - 10, contentRect.y, 10, 10);
}
 
std::vector<wxPoint> EmberForge::NodeWidget::GetConnectionPoints() const {
    std::vector<wxPoint> points;
    wxRect rect = GetClientRect();
 
    // Top center
    points.push_back(wxPoint(rect.width / 2, 0));
    // Bottom center
    points.push_back(wxPoint(rect.width / 2, rect.height));
    // Left center
    points.push_back(wxPoint(0, rect.height / 2));
    // Right center
    points.push_back(wxPoint(rect.width, rect.height / 2));
 
    return points;
}
 
// State helpers
wxColour EmberForge::NodeWidget::GetBackgroundColor() const {
    switch (interaction_state_) {
    case InteractionState::Hovered:
        return wxColour(240, 240, 255);
    case InteractionState::Selected:
        return wxColour(200, 200, 255);
    case InteractionState::Dragging:
        return wxColour(255, 255, 200);
    case InteractionState::Editing:
        return wxColour(255, 240, 240);
    default:
        return wxColour(255, 255, 255);
    }
}
 
wxColour EmberForge::NodeWidget::GetBorderColor() const {
    if (is_highlighted_) {
        return wxColour(255, 165, 0); // Orange
    }
 
    // Get colors from preferences
    auto &prefs = EmberForge::AppPreferencesManager::GetInstance().GetPreferences();
    const auto &mainPanelSettings = prefs.GetMainPanelSettings();
 
    switch (interaction_state_) {
    case InteractionState::Selected:
        return wxColour(mainPanelSettings.selectedNodeColor.r, mainPanelSettings.selectedNodeColor.g,
                        mainPanelSettings.selectedNodeColor.b);
    case InteractionState::Hovered:
        return wxColour(mainPanelSettings.hoveredNodeColor.r, mainPanelSettings.hoveredNodeColor.g,
                        mainPanelSettings.hoveredNodeColor.b);
    case InteractionState::Dragging:
        return wxColour(255, 165, 0); // Orange
    default:
        return wxColour(128, 128, 128); // Gray
    }
}
 
wxColour EmberForge::NodeWidget::GetTextColor() const {
    // Get text colors from preferences
    auto &prefs = EmberForge::AppPreferencesManager::GetInstance().GetPreferences();
    const auto &mainPanelSettings = prefs.GetMainPanelSettings();
 
    switch (interaction_state_) {
    case InteractionState::Selected:
        return wxColour(mainPanelSettings.selectedNodeTextColor.r, mainPanelSettings.selectedNodeTextColor.g,
                        mainPanelSettings.selectedNodeTextColor.b);
    case InteractionState::Hovered:
        return wxColour(mainPanelSettings.hoveredNodeTextColor.r, mainPanelSettings.hoveredNodeTextColor.g,
                        mainPanelSettings.hoveredNodeTextColor.b);
    default:
        return wxColour(0, 0, 0); // Black
    }
}
 
wxBitmap EmberForge::NodeWidget::GetNodeIcon() const {
    // Return appropriate icon based on node type
    // This is a placeholder - actual implementation would load from resources
    return wxNullBitmap;
}
 
wxString EmberForge::NodeWidget::GetDisplayText() const {
    if (!node_) {
        return "No EmberCore::Node";
    }
 
    return node_->GetName();
}
 
// Animation helpers
void EmberForge::NodeWidget::OnAnimationTimer(wxTimerEvent &event) { UpdateAnimation(); }
 
void EmberForge::NodeWidget::UpdateAnimation() {
    if (is_animating_) {
        animation_phase_ += 0.2; // Animation speed
        if (animation_phase_ > 2 * M_PI) {
            animation_phase_ -= 2 * M_PI;
        }
        Refresh();
    }
}
 
// Private helper methods
void EmberForge::NodeWidget::InitializeWidget() {
    // Set default colors
    ResetToDefaultAppearance();
 
    // Set minimum size
    SetMinSize(CalculateMinSize());
 
    // Enable double buffering to reduce flicker
    SetBackgroundStyle(wxBG_STYLE_CUSTOM);
}
 
void EmberForge::NodeWidget::UpdateColors() {
    // Colors are computed dynamically, no storage needed
}
 
void EmberForge::NodeWidget::CreateEditControl() {
    if (edit_control_ || !node_) {
        return;
    }
 
    original_name_ = node_->GetName();
 
    edit_control_ =
        new wxTextCtrl(this, wxID_ANY, original_name_, wxDefaultPosition, wxDefaultSize, wxTE_PROCESS_ENTER);
 
    edit_control_->SetSize(GetTextRect());
    edit_control_->SetFocus();
    edit_control_->SelectAll();
 
    // Bind events
    edit_control_->Bind(wxEVT_TEXT_ENTER, [this](wxCommandEvent &) { StopEditing(true); });
 
    edit_control_->Bind(wxEVT_KILL_FOCUS, [this](wxFocusEvent &event) {
        StopEditing(true);
        event.Skip();
    });
}
 
void EmberForge::NodeWidget::DestroyEditControl() {
    if (edit_control_) {
        edit_control_->Destroy();
        edit_control_ = nullptr;
    }
}
 
void EmberForge::NodeWidget::ShowContextMenu(const wxPoint &position) {
    wxMenu menu;
 
    menu.Append(wxID_ANY, "Edit", "Edit node name");
    menu.Append(wxID_ANY, "Delete", "Delete this node");
    menu.AppendSeparator();
    menu.Append(wxID_ANY, "Properties", "Show node properties");
 
    PopupMenu(&menu, position);
}
 
} // namespace EmberForge