MonitorNavigatorTab.cpp

Go to the documentation of this file.

#include "Tabs/MonitorNavigatorTab.h"
 
namespace Ember {
namespace Monitor {
 
// ============================================================================
// MonitorHierarchyView
// ============================================================================
 
MonitorHierarchyView::MonitorHierarchyView(wxWindow *parent, const EmberUI::TreeHierarchyConfig &config)
    : EmberUI::NavigatorHierarchyView(parent, config) {}
 
wxString MonitorHierarchyView::GetNodeDisplayText(EmberCore::ITreeNode *node) const {
    if (!node)
        return "Unknown Node";
 
    wxString label = node->GetName();
    label += " [" + node->GetTypeString() + "]";
 
    if (m_stateManager) {
        int status = static_cast<int>(m_stateManager->GetNodeStatus(static_cast<int64_t>(node->GetId())));
        wxString statusLabel = GetStatusLabel(status);
        if (!statusLabel.IsEmpty()) {
            label += " " + statusLabel;
        }
    }
 
    return label;
}
 
void MonitorHierarchyView::RefreshStatus() {
    auto now = std::chrono::steady_clock::now();
    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(now - m_lastRefreshTime);
    if (elapsed.count() < REFRESH_INTERVAL_MS) {
        return;
    }
    m_lastRefreshTime = now;
 
    if (!m_stateManager)
        return;
 
    wxTreeCtrl *tc = GetTreeCtrl();
    if (!tc || !tc->GetRootItem().IsOk())
        return;
 
    auto changedIds = m_stateManager->GetAndClearChangedNodes();
    if (changedIds.empty())
        return;
 
    RebuildNodeIdMap();
 
    if (changedIds.size() > m_nodeIdToItem.size() / 2) {
        UpdateStatusIcons();
    } else {
        UpdateChangedNodes(changedIds);
    }
}
 
void MonitorHierarchyView::RebuildNodeIdMap() {
    m_nodeIdToItem.clear();
    wxTreeCtrl *tc = GetTreeCtrl();
    if (!tc || !tc->GetRootItem().IsOk())
        return;
    RebuildNodeIdMapRecursive(tc->GetRootItem());
}
 
void MonitorHierarchyView::RebuildNodeIdMapRecursive(const wxTreeItemId &item) {
    if (!item.IsOk())
        return;
 
    wxTreeCtrl *tc = GetTreeCtrl();
    EmberCore::ITreeNode *node = GetNodeFromItem(item);
    if (node) {
        m_nodeIdToItem[static_cast<int64_t>(node->GetId())] = item;
    }
 
    wxTreeItemIdValue cookie;
    wxTreeItemId child = tc->GetFirstChild(item, cookie);
    while (child.IsOk()) {
        RebuildNodeIdMapRecursive(child);
        child = tc->GetNextChild(item, cookie);
    }
}
 
void MonitorHierarchyView::UpdateChangedNodes(const std::vector<int64_t> &changedIds) {
    if (!m_stateManager || changedIds.empty())
        return;
 
    wxTreeCtrl *tc = GetTreeCtrl();
    if (!tc || !tc->GetRootItem().IsOk())
        return;
 
    tc->Freeze();
 
    for (int64_t nodeId : changedIds) {
        auto it = m_nodeIdToItem.find(nodeId);
        if (it == m_nodeIdToItem.end() || !it->second.IsOk())
            continue;
 
        wxTreeItemData *rawData = tc->GetItemData(it->second);
        if (!rawData)
            continue;
 
        EmberCore::ITreeNode *node = GetNodeFromItem(it->second);
        if (node) {
            UpdateSingleItem(it->second, node);
        }
    }
 
    tc->Thaw();
}
 
void MonitorHierarchyView::UpdateSingleItem(const wxTreeItemId &item, EmberCore::ITreeNode *node) {
    wxTreeCtrl *tc = GetTreeCtrl();
    wxString label = GetNodeDisplayText(node);
    tc->SetItemText(item, label);
 
    int status = static_cast<int>(m_stateManager->GetNodeStatus(static_cast<int64_t>(node->GetId())));
 
    switch (status) {
    case 1:
        tc->SetItemTextColour(item, wxColour(100, 150, 255));
        break;
    case 2:
        tc->SetItemTextColour(item, wxColour(100, 220, 100));
        break;
    case 3:
        tc->SetItemTextColour(item, wxColour(255, 80, 80));
        break;
    case 4:
        tc->SetItemTextColour(item, wxColour(255, 180, 50));
        break;
    default:
        tc->SetItemTextColour(item, wxColour(200, 200, 200));
        break;
    }
}
 
void MonitorHierarchyView::UpdateStatusIcons() {
    wxTreeCtrl *tc = GetTreeCtrl();
    if (!tc || !m_stateManager || !tc->GetRootItem().IsOk())
        return;
 
    tc->Freeze();
 
    std::function<void(wxTreeItemId)> updateItem = [&](wxTreeItemId item) {
        if (!item.IsOk())
            return;
 
        EmberCore::ITreeNode *node = GetNodeFromItem(item);
        if (node) {
            UpdateSingleItem(item, node);
        }
 
        wxTreeItemIdValue cookie;
        wxTreeItemId child = tc->GetFirstChild(item, cookie);
        while (child.IsOk()) {
            updateItem(child);
            child = tc->GetNextChild(item, cookie);
        }
    };
 
    updateItem(tc->GetRootItem());
    tc->Thaw();
}
 
wxString MonitorHierarchyView::GetStatusLabel(int status) const {
    switch (status) {
    case 1:
        return wxString::FromUTF8("\xe2\x96\xb6");
    case 2:
        return wxString::FromUTF8("\xe2\x9c\x93");
    case 3:
        return wxString::FromUTF8("\xe2\x9c\x97");
    case 4:
        return wxString::FromUTF8("\xe2\x96\xa0");
    default:
        return "";
    }
}
 
// ============================================================================
// MonitorNavigatorTab
// ============================================================================
 
MonitorNavigatorTab::MonitorNavigatorTab(wxWindow *parent) : EmberUI::NavigatorTab(parent, /*deferLayout=*/true) {
    SetEditingEnabled(false);
    InitLayout();
    m_monitorHierView = dynamic_cast<MonitorHierarchyView *>(GetHierarchyView());
}
 
EmberUI::NavigatorHierarchyView *MonitorNavigatorTab::CreateHierarchyView(wxWindow *parent,
                                                                          const EmberUI::TreeHierarchyConfig &cfg) {
    EmberUI::TreeHierarchyConfig monitorCfg = cfg;
    monitorCfg.autoExpandDepth = 100;
    monitorCfg.syncSelectionWithCanvas = true;
    return new MonitorHierarchyView(parent, monitorCfg);
}
 
void MonitorNavigatorTab::SetMonitorTree(std::shared_ptr<EmberCore::ITreeStructure> tree,
                                         std::shared_ptr<Network::StateManager> stateManager,
                                         const std::string &treeId) {
    m_stateManager = stateManager;
    if (m_monitorHierView) {
        m_monitorHierView->SetStateManager(stateManager);
    }
 
    std::string id = treeId.empty() ? "monitored_tree" : treeId;
    SetActiveTree(tree, id);
    DrillIntoTree(id);
 
    if (m_monitorHierView) {
        m_monitorHierView->Layout();
        m_monitorHierView->wxWindow::Refresh();
    }
 
    Layout();
    wxPanel::Refresh();
}
 
void MonitorNavigatorTab::ClearMonitorTree() {
    m_stateManager.reset();
    if (m_monitorHierView) {
        m_monitorHierView->SetStateManager(nullptr);
        m_monitorHierView->InvalidateNodeIdMap();
    }
    NavigateBack();
    ClearTreeList();
}
 
void MonitorNavigatorTab::RefreshStatus() {
    if (m_monitorHierView) {
        m_monitorHierView->RefreshStatus();
    }
}
 
} // namespace Monitor
} // namespace Ember