MainPanel.cpp

Go to the documentation of this file.

#include "Panels/MainPanel.h"
 
namespace Ember {
namespace Monitor {
 
MainPanel::MainPanel(wxWindow *parent) : EmberUI::Panel(parent, "MainPanel") { CreateLayout(); }
 
void MainPanel::CreateLayout() {
    wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
 
    wxPanel *searchBar = new wxPanel(this, wxID_ANY);
    searchBar->SetBackgroundColour(wxColour(45, 45, 45));
    wxBoxSizer *searchSizer = new wxBoxSizer(wxHORIZONTAL);
 
    m_searchCtrl = new wxSearchCtrl(searchBar, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(250, -1));
    m_searchCtrl->SetDescriptiveText("Search nodes... (Ctrl+F)");
    m_searchCtrl->ShowCancelButton(true);
 
    m_searchStatus = new wxStaticText(searchBar, wxID_ANY, "");
    m_searchStatus->SetForegroundColour(wxColour(150, 150, 150));
 
    searchSizer->Add(m_searchCtrl, 0, wxALIGN_CENTER_VERTICAL | wxALL, 3);
    searchSizer->Add(m_searchStatus, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, 8);
    searchBar->SetSizer(searchSizer);
 
    sizer->Add(searchBar, 0, wxEXPAND);
 
    m_treeCanvas = new MonitorTreeCanvas(this);
    m_treeCanvas->SetStatusProvider(this);
    sizer->Add(m_treeCanvas, 1, wxEXPAND);
 
    SetSizer(sizer);
 
    m_searchCtrl->Bind(wxEVT_TEXT, &MainPanel::OnSearchText, this);
    m_searchCtrl->Bind(wxEVT_SEARCHCTRL_SEARCH_BTN, &MainPanel::OnSearchEnter, this);
    m_searchCtrl->Bind(wxEVT_TEXT_ENTER, &MainPanel::OnSearchEnter, this);
    m_searchCtrl->Bind(wxEVT_SEARCHCTRL_CANCEL_BTN, &MainPanel::OnSearchCancel, this);
}
 
void MainPanel::OnSearchText(wxCommandEvent &event) {
    wxString query = m_searchCtrl->GetValue();
    if (query.IsEmpty()) {
        m_searchResults.clear();
        m_searchIndex = 0;
        m_searchStatus->SetLabel("");
        return;
    }
    CollectSearchResults(query);
    if (!m_searchResults.empty()) {
        m_searchIndex = 0;
        NavigateToResult(m_searchIndex);
    } else {
        m_searchStatus->SetLabel("No matches");
    }
}
 
void MainPanel::OnSearchEnter(wxCommandEvent &event) {
    if (m_searchResults.empty())
        return;
    m_searchIndex = (m_searchIndex + 1) % m_searchResults.size();
    NavigateToResult(m_searchIndex);
}
 
void MainPanel::OnSearchCancel(wxCommandEvent &event) {
    m_searchCtrl->SetValue("");
    m_searchResults.clear();
    m_searchIndex = 0;
    m_searchStatus->SetLabel("");
    m_treeCanvas->SetFocus();
}
 
void MainPanel::NavigateToResult(size_t index) {
    if (index >= m_searchResults.size())
        return;
 
    EmberCore::ITreeNode *node = m_searchResults[index];
 
    EmberCore::ITreeNode *parent = node->GetParent();
    while (parent) {
        if (!parent->AreChildrenVisible()) {
            parent->SetChildrenVisible(true);
        }
        parent = parent->GetParent();
    }
 
    m_treeCanvas->SetSelectedNode(node);
    m_treeCanvas->CenterOnNode(node);
    m_treeCanvas->MarkDirty();
 
    m_searchStatus->SetLabel(wxString::Format("%zu of %zu", index + 1, m_searchResults.size()));
}
 
void MainPanel::CollectSearchResults(const wxString &query) {
    m_searchResults.clear();
    auto tree = m_treeCanvas->GetTree();
    if (!tree || !tree->HasRootNode())
        return;
 
    wxString lowerQuery = query.Lower();
    tree->GetRootNode()->Accept([&](EmberCore::ITreeNode *node) {
        wxString name = node->GetName();
        if (name.Lower().Contains(lowerQuery)) {
            m_searchResults.push_back(node);
        }
    });
}
 
void MainPanel::SetTree(std::shared_ptr<Ember::Network::TCPTreeAdapter> adapter,
                        std::shared_ptr<Network::StateManager> stateManager) {
    m_stateManager = stateManager;
    m_adapter = std::move(adapter);
    m_treeCanvas->SetTree(m_adapter);
 
    m_searchResults.clear();
    m_searchIndex = 0;
    m_searchCtrl->SetValue("");
    m_searchStatus->SetLabel("");
 
    CallAfter([this]() { m_treeCanvas->CenterOnNode(m_treeCanvas->GetTree()->GetRootNode()); });
}
 
void MainPanel::ClearTree() {
    m_stateManager.reset();
    m_adapter.reset();
    m_treeCanvas->SetTree(nullptr);
    m_searchResults.clear();
    m_searchIndex = 0;
    m_searchCtrl->SetValue("");
    m_searchStatus->SetLabel("");
}
 
int MainPanel::GetNodeStatus(int64_t nodeId) const {
    if (!m_stateManager)
        return 0;
    return static_cast<int>(m_stateManager->GetNodeStatus(nodeId));
}
 
bool MainPanel::IsNodeInExecutionPath(int64_t nodeId) const {
    if (!m_stateManager)
        return false;
 
    const auto &path = m_stateManager->GetExecutionPath();
    for (auto id : path) {
        if (id == nodeId)
            return true;
    }
    return false;
}
 
void MainPanel::GetExecutionPathIds(std::set<int64_t> &outIds) const {
    if (!m_stateManager)
        return;
 
    const auto &path = m_stateManager->GetExecutionPath();
    outIds.insert(path.begin(), path.end());
}
 
void MainPanel::SetNodeSelectionCallback(NodeSelectionCallback callback) {
    m_treeCanvas->SetNodeSelectionCallback(callback);
}
 
} // namespace Monitor
} // namespace Ember