ForgeTreeCanvas.cpp

Go to the documentation of this file.

#include "Scenes/ForgeTreeCanvas.h"
#include "Utils/AppPreferences.h"
#include "Utils/Logger.h"
#include "Utils/PerformanceMonitor.h"
#include "Utils/ResourcePath.h"
#include <cctype>
 
namespace EmberForge {
 
ForgeTreeCanvas::ForgeTreeCanvas(wxWindow *parent, wxWindowID id) : EmberUI::TreeCanvas(parent, id) {
    LoadPreferences();
 
    auto &config = GetConfig();
    config.icon_directory = ResourcePath::GetDir("icons/tree_nodes").ToStdString();
    LoadTypeIcons();
}
 
void ForgeTreeCanvas::LoadPreferences() {
    auto &prefs = AppPreferencesManager::GetInstance().GetPreferences();
    const auto &btView = prefs.GetBehaviorTreeViewSettings();
    const auto &mainPanel = prefs.GetMainPanelSettings();
    const auto &perf = prefs.GetPerformanceSettings();
 
    auto &cfg = GetConfig();
 
    cfg.zoom_step = btView.zoomStepSize;
    cfg.mouse_wheel_sensitivity = btView.mouseWheelSensitivity;
    cfg.pan_sensitivity = btView.panSensitivity;
    cfg.zoom_follows_cursor = btView.zoomFollowsCursor;
    cfg.enable_smooth_panning = btView.enableSmoothPanning;
    cfg.pan_smoothness = btView.panSmoothness;
    cfg.pan_step_size = btView.panStepSize;
 
    cfg.enable_viewport_culling = perf.enableViewportCulling;
    cfg.viewport_culling_margin = perf.viewportCullingMargin;
 
    SetShowGrid(mainPanel.showGrid);
    SetShowMinimap(mainPanel.showMinimap);
    SetShowBreadcrumb(mainPanel.showCanvasBreadcrumb);
    cfg.grid_size = mainPanel.gridSize;
    cfg.grid_color = wxColour(mainPanel.gridLineColor.r, mainPanel.gridLineColor.g, mainPanel.gridLineColor.b);
 
    cfg.highlight_path_to_selected = mainPanel.highlightPathToSelected;
    cfg.path_highlight_color =
        wxColour(mainPanel.pathHighlightColor.r, mainPanel.pathHighlightColor.g, mainPanel.pathHighlightColor.b);
 
    cfg.background_color = wxColour(mainPanel.canvasBackgroundColor.r, mainPanel.canvasBackgroundColor.g,
                                    mainPanel.canvasBackgroundColor.b);
 
    cfg.connection_color =
        wxColour(mainPanel.connectionLineColor.r, mainPanel.connectionLineColor.g, mainPanel.connectionLineColor.b);
 
    cfg.node_color = wxColour(mainPanel.idleNodeBgColor.r, mainPanel.idleNodeBgColor.g, mainPanel.idleNodeBgColor.b);
    cfg.border_color =
        wxColour(mainPanel.idleNodeBorderColor.r, mainPanel.idleNodeBorderColor.g, mainPanel.idleNodeBorderColor.b);
    cfg.text_color =
        wxColour(mainPanel.idleNodeTextColor.r, mainPanel.idleNodeTextColor.g, mainPanel.idleNodeTextColor.b);
    cfg.selected_border_color =
        wxColour(mainPanel.selectedNodeColor.r, mainPanel.selectedNodeColor.g, mainPanel.selectedNodeColor.b);
    cfg.hovered_border_color =
        wxColour(mainPanel.hoveredNodeColor.r, mainPanel.hoveredNodeColor.g, mainPanel.hoveredNodeColor.b);
 
    SetShowOverlayInfo(false);
 
    LOG_INFO("ForgeTreeCanvas", "Preferences loaded");
}
 
void ForgeTreeCanvas::OnBeforePaintOverlays(wxDC &dc) {
    auto &prefs = AppPreferencesManager::GetInstance().GetPreferences();
    const auto &btView = prefs.GetBehaviorTreeViewSettings();
 
    dc.SetUserScale(1.0, 1.0);
    dc.SetDeviceOrigin(0, 0);
 
    wxSize panelSize = GetSize();
 
    auto calcPos = [&panelSize](AppPreferences::TextAnchor anchor, int offX, int offY) -> wxPoint {
        switch (anchor) {
        case AppPreferences::TextAnchor::TopRight:
            return {panelSize.x - offX, offY};
        case AppPreferences::TextAnchor::BottomLeft:
            return {offX, panelSize.y - offY};
        case AppPreferences::TextAnchor::BottomRight:
            return {panelSize.x - offX, panelSize.y - offY};
        default:
            return {offX, offY};
        }
    };
 
    if (btView.showCoordinateInfo) {
        wxColour c(btView.coordinateInfoColor.r, btView.coordinateInfoColor.g, btView.coordinateInfoColor.b);
        dc.SetTextForeground(c);
        dc.SetFont(
            wxFont(btView.coordinateInfoFontSize, wxFONTFAMILY_TELETYPE, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL));
        wxPoint viewOfs = GetViewOffset();
        wxString zoomText = wxString::Format("Zoom: %.0f%% | Pan: (%d, %d)", GetZoom() * 100, viewOfs.x, viewOfs.y);
        if (IsInFocusMode())
            zoomText += " | FOCUS MODE";
        dc.DrawText(zoomText, calcPos(btView.coordinateInfoAnchor, btView.coordinateInfoX, btView.coordinateInfoY));
    }
 
    auto *selectedNode = GetSelectedNode();
    if (btView.showSelectedNodeInfo && selectedNode) {
        wxColour c(btView.selectedNodeInfoColor.r, btView.selectedNodeInfoColor.g, btView.selectedNodeInfoColor.b);
        dc.SetTextForeground(c);
        dc.SetFont(
            wxFont(btView.selectedNodeInfoFontSize, wxFONTFAMILY_TELETYPE, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL));
        EmberCore::String selectedText =
            "Selected: " + selectedNode->GetName() + " [" + selectedNode->GetTypeString() + "]";
 
        auto *statusProvider = GetStatusProvider();
        if (statusProvider) {
            int status = statusProvider->GetNodeStatus(static_cast<int64_t>(selectedNode->GetId()));
            wxString statusNames[] = {"Idle", "Running", "Success", "Failure", "Halted"};
            selectedText += " | Status: " + (status >= 0 && status <= 4 ? statusNames[status] : "Unknown");
        }
        dc.DrawText(selectedText,
                    calcPos(btView.selectedNodeInfoAnchor, btView.selectedNodeInfoX, btView.selectedNodeInfoY));
    }
 
    if (btView.showTreeInfo) {
        auto tree = GetTree();
        if (tree && tree->HasRootNode()) {
            wxColour c(btView.treeInfoColor.r, btView.treeInfoColor.g, btView.treeInfoColor.b);
            dc.SetTextForeground(c);
            dc.SetFont(wxFont(btView.treeInfoFontSize, wxFONTFAMILY_TELETYPE, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL));
            wxString statsText = wxString::Format("Nodes: %lu", static_cast<unsigned long>(tree->GetNodeCount()));
            dc.DrawText(statsText, calcPos(btView.treeInfoAnchor, btView.treeInfoX, btView.treeInfoY));
        }
    }
 
    if (btView.showFPS) {
        wxColour c(btView.fpsColor.r, btView.fpsColor.g, btView.fpsColor.b);
        dc.SetTextForeground(c);
        dc.SetFont(wxFont(btView.fpsFontSize, wxFONTFAMILY_TELETYPE, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD));
        PerformanceMonitor &mon = PerformanceMonitor::GetInstance();
        wxString txt = wxString::Format("FPS: %.1f", mon.GetCurrentFPS());
        dc.DrawText(txt, calcPos(btView.fpsAnchor, btView.fpsX, btView.fpsY));
    }
 
    if (btView.showControlsHelp) {
        wxColour c(btView.controlsHelpColor.r, btView.controlsHelpColor.g, btView.controlsHelpColor.b);
        dc.SetTextForeground(c);
        dc.SetFont(wxFont(btView.controlsHelpFontSize, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL));
        EmberCore::String helpText = "Controls: Click=Select | DblClick=Center | Wheel=Zoom | " +
                                     btView.resetViewHotkey + "=Reset | " + btView.centerOnNodeHotkey +
                                     "=Expand/Collapse | F=Focus | " + btView.deleteNodeHotkey + "=Delete";
        if (IsInFocusMode())
            helpText += " | Esc=Exit Focus";
        dc.DrawText(helpText, calcPos(btView.controlsHelpAnchor, btView.controlsHelpX, btView.controlsHelpY));
    }
 
    PERF_END_FRAME();
}
 
bool ForgeTreeCanvas::MatchesHotkey(int keyCode, const EmberCore::String &hotkeyStr) const {
    if (hotkeyStr.empty())
        return false;
 
    if (hotkeyStr == "Up")
        return keyCode == WXK_UP;
    if (hotkeyStr == "Down")
        return keyCode == WXK_DOWN;
    if (hotkeyStr == "Left")
        return keyCode == WXK_LEFT;
    if (hotkeyStr == "Right")
        return keyCode == WXK_RIGHT;
    if (hotkeyStr == "Delete")
        return keyCode == WXK_DELETE;
    if (hotkeyStr == "Escape")
        return keyCode == WXK_ESCAPE;
    if (hotkeyStr == "Space")
        return keyCode == WXK_SPACE;
    if (hotkeyStr == "Tab")
        return keyCode == WXK_TAB;
    if (hotkeyStr == "Enter" || hotkeyStr == "Return")
        return keyCode == WXK_RETURN;
 
    if (hotkeyStr.length() == 1) {
        char ch = std::toupper(static_cast<unsigned char>(hotkeyStr[0]));
        return keyCode == static_cast<int>(ch);
    }
 
    return false;
}
 
void ForgeTreeCanvas::OnKeyDown(wxKeyEvent &event) {
    auto &prefs = AppPreferencesManager::GetInstance().GetPreferences();
    const auto &btView = prefs.GetBehaviorTreeViewSettings();
    int keyCode = event.GetKeyCode();
 
    float panStep = GetConfig().pan_step_size * GetConfig().pan_sensitivity;
 
    if (MatchesHotkey(keyCode, btView.resetViewHotkey)) {
        ResetView();
        MarkDirty();
        return;
    }
    if (MatchesHotkey(keyCode, btView.centerOnNodeHotkey)) {
        auto *sel = GetSelectedNode();
        if (sel && sel->GetChildCount() > 0) {
            bool visible = sel->AreChildrenVisible();
            sel->SetChildrenVisible(!visible);
            InvalidateLayout();
        }
        return;
    }
    if (MatchesHotkey(keyCode, btView.panUpHotkey)) {
        SetTargetOffset(GetTargetOffset() + wxPoint(0, static_cast<int>(panStep)));
        MarkDirty();
        return;
    }
    if (MatchesHotkey(keyCode, btView.panDownHotkey)) {
        SetTargetOffset(GetTargetOffset() + wxPoint(0, -static_cast<int>(panStep)));
        MarkDirty();
        return;
    }
    if (MatchesHotkey(keyCode, btView.panLeftHotkey)) {
        SetTargetOffset(GetTargetOffset() + wxPoint(static_cast<int>(panStep), 0));
        MarkDirty();
        return;
    }
    if (MatchesHotkey(keyCode, btView.panRightHotkey)) {
        SetTargetOffset(GetTargetOffset() + wxPoint(-static_cast<int>(panStep), 0));
        MarkDirty();
        return;
    }
 
    TreeCanvas::OnKeyDown(event);
}
 
wxColour ForgeTreeCanvas::GetNodeFillColor(EmberCore::ITreeNode *node, bool selected, bool hovered) {
    auto &prefs = AppPreferencesManager::GetInstance().GetPreferences();
    const auto &mp = prefs.GetMainPanelSettings();
 
    wxColour base(mp.idleNodeBgColor.r, mp.idleNodeBgColor.g, mp.idleNodeBgColor.b);
 
    if (selected)
        return ApplyTint(base, mp.selectedNodeBgTint);
    if (hovered)
        return ApplyTint(base, mp.hoveredNodeBgTint);
 
    if (node->IsSubTreeReference()) {
        return wxColour(std::min(255, base.Red() + 10), std::min(255, base.Green() + 10),
                        std::max(0, base.Blue() - 20));
    }
    return base;
}
 
wxColour ForgeTreeCanvas::GetNodeBorderColor(EmberCore::ITreeNode *node, bool selected, bool hovered) {
    auto &prefs = AppPreferencesManager::GetInstance().GetPreferences();
    const auto &mp = prefs.GetMainPanelSettings();
 
    if (selected)
        return wxColour(mp.selectedNodeColor.r, mp.selectedNodeColor.g, mp.selectedNodeColor.b);
    if (hovered)
        return wxColour(mp.hoveredNodeColor.r, mp.hoveredNodeColor.g, mp.hoveredNodeColor.b);
 
    if (node->IsSubTreeReference())
        return wxColour(80, 120, 200);
 
    return wxColour(mp.idleNodeBorderColor.r, mp.idleNodeBorderColor.g, mp.idleNodeBorderColor.b);
}
 
wxColour ForgeTreeCanvas::GetNodeTextColor(EmberCore::ITreeNode *node, bool selected, bool hovered) {
    auto &prefs = AppPreferencesManager::GetInstance().GetPreferences();
    const auto &mp = prefs.GetMainPanelSettings();
 
    if (selected)
        return wxColour(mp.selectedNodeTextColor.r, mp.selectedNodeTextColor.g, mp.selectedNodeTextColor.b);
    if (hovered)
        return wxColour(mp.hoveredNodeTextColor.r, mp.hoveredNodeTextColor.g, mp.hoveredNodeTextColor.b);
 
    return wxColour(mp.idleNodeTextColor.r, mp.idleNodeTextColor.g, mp.idleNodeTextColor.b);
}
 
wxColour ForgeTreeCanvas::ApplyTint(const wxColour &color, float tint) {
    int r = color.Red();
    int g = color.Green();
    int b = color.Blue();
 
    if (tint > 0) {
        r = r + static_cast<int>((255 - r) * tint);
        g = g + static_cast<int>((255 - g) * tint);
        b = b + static_cast<int>((255 - b) * tint);
    } else {
        r = r + static_cast<int>(r * tint);
        g = g + static_cast<int>(g * tint);
        b = b + static_cast<int>(b * tint);
    }
 
    return wxColour(std::max(0, std::min(255, r)), std::max(0, std::min(255, g)), std::max(0, std::min(255, b)));
}
 
} // namespace EmberForge