BlackboardScene.cpp

Go to the documentation of this file.

#include "Scenes/BlackboardScene.h"
#include <algorithm>
#include <cmath>
#include <wx/dcbuffer.h>
 
BlackboardScene::BlackboardScene(wxWindow *parent) : m_panel(nullptr), m_scrollPanel(nullptr) {
    m_panel = new wxPanel(parent, wxID_ANY);
    m_panel->SetName("BlackboardScene");
    m_panel->SetBackgroundColour(wxColour(40, 40, 40));
    CreateLayout();
 
    m_scrollTimer = new wxTimer();
    m_scrollTimer->Bind(wxEVT_TIMER, &BlackboardScene::OnScrollTimer, this);
}
 
BlackboardScene::~BlackboardScene() {
    if (m_scrollTimer) {
        m_scrollTimer->Stop();
        delete m_scrollTimer;
        m_scrollTimer = nullptr;
    }
}
 
void BlackboardScene::CreateLayout() {
    wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
 
    m_scrollPanel =
        new wxScrolledWindow(m_panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxVSCROLL | wxBORDER_NONE);
    m_scrollPanel->SetBackgroundColour(wxColour(40, 40, 40));
    m_scrollPanel->SetScrollRate(0, 1);
    m_scrollPanel->SetBackgroundStyle(wxBG_STYLE_PAINT);
 
    m_scrollPanel->Bind(wxEVT_PAINT, &BlackboardScene::OnPaint, this);
    m_scrollPanel->Bind(wxEVT_LEFT_DOWN, &BlackboardScene::OnLeftDown, this);
    m_scrollPanel->Bind(wxEVT_MOUSEWHEEL, &BlackboardScene::OnMouseWheel, this);
 
    sizer->Add(m_scrollPanel, 1, wxEXPAND);
    m_panel->SetSizer(sizer);
}
 
void BlackboardScene::SetBlackboards(const std::map<std::string, std::shared_ptr<EmberCore::Blackboard>> &bbs,
                                     const std::map<std::string, std::vector<std::string>> &includesMap) {
    m_blackboards = bbs;
    m_includesMap = includesMap;
    m_collapsedBlackboards.clear();
 
    m_sortedBBIds.clear();
    m_sortedBBIds.reserve(m_blackboards.size());
    for (const auto &kv : m_blackboards) {
        m_sortedBBIds.push_back(kv.first);
    }
    std::sort(m_sortedBBIds.begin(), m_sortedBBIds.end());
 
    if (m_scrollPanel)
        m_scrollPanel->Refresh();
}
 
void BlackboardScene::ClearBlackboards() {
    m_blackboards.clear();
    m_includesMap.clear();
    m_sortedBBIds.clear();
    m_collapsedBlackboards.clear();
    m_bbYPositions.clear();
    if (m_scrollPanel)
        m_scrollPanel->Refresh();
}
 
void BlackboardScene::OnPaint(wxPaintEvent &) {
    wxAutoBufferedPaintDC dc(m_scrollPanel);
    m_scrollPanel->DoPrepareDC(dc);
    DrawBlackboardCards(dc);
}
 
void BlackboardScene::DrawBlackboardCards(wxDC &dc) {
    dc.SetBackground(wxBrush(wxColour(40, 40, 40)));
    dc.Clear();
 
    m_bbYPositions.clear();
 
    if (m_blackboards.empty()) {
        dc.SetTextForeground(wxColour(150, 150, 150));
        dc.SetFont(wxFont(11, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_ITALIC, wxFONTWEIGHT_NORMAL));
        dc.DrawText("No blackboards loaded", 20, 20);
        return;
    }
 
    int panelWidth = m_scrollPanel->GetClientSize().GetWidth();
    if (panelWidth < 300)
        panelWidth = 600;
    int contentWidth = panelWidth - 30;
    int x = 15;
    int y = 10;
 
    // Viewport for culling: only draw items overlapping the visible region
    int viewY0, viewY1;
    {
        int scrollPx = 0;
        m_scrollPanel->CalcUnscrolledPosition(0, 0, nullptr, &scrollPx);
        viewY0 = scrollPx;
        viewY1 = scrollPx + m_scrollPanel->GetClientSize().GetHeight();
    }
 
    auto isVisible = [&](int top, int height) { return top + height >= viewY0 && top <= viewY1; };
 
    // Binary-search style truncation instead of char-by-char removal
    auto truncate = [&dc](const wxString &text, int maxWidth) -> wxString {
        if (maxWidth <= 0)
            return text;
        if (dc.GetTextExtent(text).GetWidth() <= maxWidth)
            return text;
        size_t lo = 0, hi = text.Length();
        while (lo < hi) {
            size_t mid = (lo + hi + 1) / 2;
            if (dc.GetTextExtent(text.Left(mid) + "...").GetWidth() <= maxWidth)
                lo = mid;
            else
                hi = mid - 1;
        }
        return lo > 0 ? text.Left(lo) + "..." : "...";
    };
 
    // --- Summary Box ---
    {
        int summaryHeight = 60;
        if (isVisible(y, summaryHeight)) {
            int totalBBs = static_cast<int>(m_blackboards.size());
            int totalEntries = 0;
            for (const auto &kv : m_blackboards) {
                if (kv.second)
                    totalEntries += static_cast<int>(kv.second->GetEntryCount());
            }
 
            dc.SetBrush(wxBrush(wxColour(50, 50, 60)));
            dc.SetPen(wxPen(wxColour(100, 130, 200), 1));
            dc.DrawRoundedRectangle(x, y, contentWidth, summaryHeight, 5);
 
            dc.SetTextForeground(wxColour(130, 180, 255));
            dc.SetFont(wxFont(11, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD));
            dc.DrawText("Blackboard Overview", x + 10, y + 8);
 
            dc.SetFont(wxFont(9, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL));
            dc.SetTextForeground(wxColour(200, 200, 200));
            dc.DrawText(wxString::Format("Total: %d blackboard(s), %d entries", totalBBs, totalEntries), x + 15,
                        y + 32);
        }
        y += summaryHeight + 15;
    }
 
    // Column layout constants
    int tableX = x + 15;
    int tableWidth = contentWidth - 40;
    int col1W = tableWidth * 45 / 100;
    int col2W = tableWidth * 25 / 100;
    int col3W = tableWidth - col1W - col2W;
 
    // Pre-create fonts to avoid repeated construction
    wxFont headerFont(9, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD);
    wxFont incFont(9, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);
    wxFont tableHeaderFont(9, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD);
    wxFont monoFont(9, wxFONTFAMILY_TELETYPE, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);
 
    // --- Per-blackboard cards ---
    for (const auto &bbId : m_sortedBBIds) {
        auto bbIt = m_blackboards.find(bbId);
        if (bbIt == m_blackboards.end() || !bbIt->second)
            continue;
 
        const auto &bb = bbIt->second;
        size_t entryCount = bb->GetEntryCount();
        bool isCollapsed = m_collapsedBlackboards.count(bbId) > 0;
 
        // Calculate total height of this card to allow skipping if entirely off-screen
        int cardHeight = CARD_HEADER_H + 2;
        if (!isCollapsed && entryCount > 0)
            cardHeight += ROW_H + static_cast<int>(entryCount) * ROW_H;
        cardHeight += 10;
 
        m_bbYPositions[bbId] = y;
 
        // Skip drawing if entirely outside viewport (but still advance y)
        if (y > viewY1) {
            y += cardHeight;
            continue;
        }
        if (y + cardHeight < viewY0) {
            y += cardHeight;
            continue;
        }
 
        // --- Card header ---
        if (isVisible(y, CARD_HEADER_H)) {
            dc.SetBrush(wxBrush(wxColour(70, 50, 90)));
            dc.SetPen(wxPen(wxColour(150, 100, 200), 1));
            dc.DrawRoundedRectangle(x + 10, y, contentWidth - 20, CARD_HEADER_H, 3);
 
            int triX = x + 18;
            int triY = y + (CARD_HEADER_H / 2) - 4;
            dc.SetPen(wxPen(wxColour(200, 170, 240), 1));
            dc.SetBrush(wxBrush(wxColour(200, 170, 240)));
            if (isCollapsed) {
                wxPoint tri[3] = {wxPoint(triX, triY), wxPoint(triX, triY + 8), wxPoint(triX + 6, triY + 4)};
                dc.DrawPolygon(3, tri);
            } else {
                wxPoint tri[3] = {wxPoint(triX, triY), wxPoint(triX + 8, triY), wxPoint(triX + 4, triY + 6)};
                dc.DrawPolygon(3, tri);
            }
 
            dc.SetTextForeground(wxColour(220, 180, 255));
            dc.SetFont(headerFont);
            wxString headerText =
                wxString::Format("[%s] (%zu entr%s)", bbId, entryCount, entryCount == 1 ? "y" : "ies");
            dc.DrawText(headerText, x + 32, y + 4);
 
            auto incIt = m_includesMap.find(bbId);
            if (incIt != m_includesMap.end() && !incIt->second.empty()) {
                dc.SetTextForeground(wxColour(180, 150, 200));
                dc.SetFont(incFont);
                wxString incText = "includes: {";
                for (size_t i = 0; i < incIt->second.size(); ++i) {
                    if (i > 0)
                        incText += " ";
                    incText += wxString::FromUTF8(incIt->second[i]);
                }
                incText += "}";
                int maxW = contentWidth - 250;
                if (maxW > 0)
                    incText = truncate(incText, maxW);
                int incTextW = dc.GetTextExtent(incText).GetWidth();
                dc.DrawText(incText, x + contentWidth - 20 - incTextW, y + 6);
            }
        }
 
        y += CARD_HEADER_H + 2;
 
        // --- Entry table (only if expanded) ---
        if (!isCollapsed && entryCount > 0) {
            // Table header row
            if (isVisible(y, ROW_H)) {
                dc.SetBrush(wxBrush(wxColour(55, 55, 65)));
                dc.SetPen(wxPen(wxColour(80, 80, 100), 1));
                dc.DrawRectangle(tableX, y, col1W, ROW_H);
                dc.DrawRectangle(tableX + col1W, y, col2W, ROW_H);
                dc.DrawRectangle(tableX + col1W + col2W, y, col3W, ROW_H);
 
                dc.SetTextForeground(wxColour(180, 180, 220));
                dc.SetFont(tableHeaderFont);
                dc.DrawText("Key", tableX + 5, y + 4);
                dc.DrawText("Type", tableX + col1W + 5, y + 4);
                dc.DrawText("Value", tableX + col1W + col2W + 5, y + 4);
            }
            y += ROW_H;
 
            // Entry rows
            size_t ei = 0;
            for (const auto &entryPair : bb->GetEntries()) {
                const auto &entry = entryPair.second;
                if (!entry)
                    continue;
 
                if (isVisible(y, ROW_H)) {
                    wxColour rowBg = (ei % 2 == 0) ? wxColour(45, 45, 50) : wxColour(50, 50, 55);
                    dc.SetBrush(wxBrush(rowBg));
                    dc.SetPen(wxPen(wxColour(60, 60, 70), 1));
                    dc.DrawRectangle(tableX, y, col1W, ROW_H);
                    dc.DrawRectangle(tableX + col1W, y, col2W, ROW_H);
                    dc.DrawRectangle(tableX + col1W + col2W, y, col3W, ROW_H);
 
                    dc.SetFont(monoFont);
                    dc.SetTextForeground(wxColour(200, 200, 200));
                    dc.DrawText(truncate(wxString::FromUTF8(entry->GetKey()), col1W - 10), tableX + 5, y + 4);
 
                    dc.SetTextForeground(wxColour(150, 200, 180));
                    dc.DrawText(truncate(wxString::FromUTF8(entry->GetTypeString()), col2W - 10), tableX + col1W + 5,
                                y + 4);
 
                    dc.SetTextForeground(wxColour(180, 180, 150));
                    dc.DrawText(truncate(wxString::FromUTF8(entry->GetValue()), col3W - 10), tableX + col1W + col2W + 5,
                                y + 4);
                }
 
                y += ROW_H;
                ++ei;
            }
        }
 
        y += 10;
    }
 
    m_scrollPanel->SetVirtualSize(panelWidth, y + 20);
}
 
void BlackboardScene::OnMouseWheel(wxMouseEvent &event) {
    if (!m_scrollPanel)
        return;
 
    int rotation = event.GetWheelRotation();
    double delta = -(static_cast<double>(rotation) / event.GetWheelDelta()) * SCROLL_PIXELS_PER_NOTCH;
 
    m_scrollVelocity += delta;
 
    int viewStartX, viewStartY;
    m_scrollPanel->GetViewStart(&viewStartX, &viewStartY);
    m_scrollY = static_cast<double>(viewStartY);
 
    if (!m_scrollTimer->IsRunning()) {
        m_scrollTimer->Start(16);
    }
}
 
void BlackboardScene::OnScrollTimer(wxTimerEvent &) {
    if (!m_scrollPanel) {
        m_scrollTimer->Stop();
        return;
    }
 
    m_scrollY += m_scrollVelocity;
    m_scrollVelocity *= SCROLL_FRICTION;
 
    int virtualH = m_scrollPanel->GetVirtualSize().GetHeight();
    int clientH = m_scrollPanel->GetClientSize().GetHeight();
    int maxScroll = std::max(0, virtualH - clientH);
 
    if (m_scrollY < 0.0)
        m_scrollY = 0.0;
    if (m_scrollY > maxScroll)
        m_scrollY = maxScroll;
 
    m_scrollPanel->Scroll(-1, static_cast<int>(m_scrollY));
 
    if (std::abs(m_scrollVelocity) < 0.5) {
        m_scrollVelocity = 0.0;
        m_scrollTimer->Stop();
    }
}
 
void BlackboardScene::OnLeftDown(wxMouseEvent &event) {
    int scrollY = 0;
    m_scrollPanel->CalcUnscrolledPosition(0, event.GetPosition().y, nullptr, &scrollY);
 
    for (const auto &kv : m_bbYPositions) {
        if (scrollY >= kv.second && scrollY < kv.second + CARD_HEADER_H) {
            if (m_collapsedBlackboards.count(kv.first)) {
                m_collapsedBlackboards.erase(kv.first);
            } else {
                m_collapsedBlackboards.insert(kv.first);
            }
            m_scrollPanel->Refresh();
            return;
        }
    }
 
    event.Skip();
}
 
void BlackboardScene::ScrollToBlackboard(const std::string &bbId) {
    m_collapsedBlackboards.erase(bbId);
    m_scrollPanel->Refresh();
    m_scrollPanel->Update();
 
    auto it = m_bbYPositions.find(bbId);
    if (it == m_bbYPositions.end())
        return;
 
    m_scrollVelocity = 0.0;
    m_scrollY = static_cast<double>(it->second);
 
    int virtualH = m_scrollPanel->GetVirtualSize().GetHeight();
    int clientH = m_scrollPanel->GetClientSize().GetHeight();
    int maxScroll = std::max(0, virtualH - clientH);
    if (m_scrollY > maxScroll)
        m_scrollY = maxScroll;
 
    m_scrollPanel->Scroll(-1, static_cast<int>(m_scrollY));
}