LogTab.cpp

Go to the documentation of this file.

#include "Tabs/LogTab.h"
#include "Utils/AppPreferences.h"
#include <fstream>
#include <iomanip>
#include <sstream>
#include <wx/clipbrd.h>
#include <wx/filedlg.h>
#include <wx/statline.h>
#include <wx/textfile.h>
#include <wx/wupdlock.h>
 
namespace EmberForge {
 
// ============================================================================
// VirtualLogListCtrl Implementation
// ============================================================================
 
VirtualLogListCtrl::VirtualLogListCtrl(wxWindow *parent, wxWindowID id, LogTab *logTab)
    : wxListCtrl(parent, id, wxDefaultPosition, wxDefaultSize,
                 wxLC_REPORT | wxLC_VIRTUAL | wxLC_SINGLE_SEL | wxLC_HRULES | wxLC_VRULES),
      m_logTab(logTab), m_entries(nullptr) {
    // Set dark theme colors
    SetBackgroundColour(wxColour(30, 30, 30));
    SetForegroundColour(wxColour(220, 220, 220));
 
    // Add columns
    InsertColumn(0, "Time", wxLIST_FORMAT_LEFT, 85);
    InsertColumn(1, "Level", wxLIST_FORMAT_CENTER, 70);
    InsertColumn(2, "Category", wxLIST_FORMAT_LEFT, 100);
    InsertColumn(3, "Message", wxLIST_FORMAT_LEFT, 500);
}
 
void VirtualLogListCtrl::SetEntries(std::vector<std::shared_ptr<EmberCore::LogEntry>> *entries) {
    m_entries = entries;
    // Tell the list how many items we have - this is the key to virtual lists!
    SetItemCount(entries ? entries->size() : 0);
}
 
wxString VirtualLogListCtrl::OnGetItemText(long item, long column) const {
    // This is called by wxWidgets when it needs to display text for a cell
    // Only called for VISIBLE rows - this is why virtual lists are fast!
 
    if (!m_entries || item < 0 || item >= static_cast<long>(m_entries->size())) {
        return "";
    }
 
    const auto &entry = (*m_entries)[item];
 
    switch (column) {
    case 0:
        return m_logTab->FormatTimestamp(entry->timestamp);
    case 1:
        return m_logTab->GetLevelString(entry->level);
    case 2:
        return wxString(entry->category);
    case 3:
        return wxString(entry->message);
    default:
        return "";
    }
}
 
wxListItemAttr *VirtualLogListCtrl::OnGetItemAttr(long item) const {
    // This is called by wxWidgets when it needs attributes (colors) for a row
    // Only called for VISIBLE rows!
 
    if (!m_entries || item < 0 || item >= static_cast<long>(m_entries->size())) {
        return nullptr;
    }
 
    const auto &entry = (*m_entries)[item];
 
    // Set text color based on log level
    m_itemAttr.SetTextColour(m_logTab->GetLevelColor(entry->level));
    m_itemAttr.SetBackgroundColour(wxColour(30, 30, 30));
 
    return const_cast<wxListItemAttr *>(&m_itemAttr);
}
 
// ============================================================================
// LogTab Implementation
// ============================================================================
 
wxBEGIN_EVENT_TABLE(LogTab, wxPanel) EVT_CHOICE(ID_LEVEL_FILTER, LogTab::OnLevelFilterChanged) EVT_COMBOBOX(
    ID_CATEGORY_FILTER, LogTab::OnCategoryFilterChanged) EVT_TEXT(ID_CATEGORY_FILTER, LogTab::OnCategoryFilterChanged)
    EVT_SEARCHCTRL_SEARCH_BTN(ID_SEARCH_CTRL, LogTab::OnSearchTextChanged)
        EVT_TEXT(ID_SEARCH_CTRL, LogTab::OnSearchTextChanged) EVT_CHECKBOX(ID_AUTO_SCROLL, LogTab::OnAutoScrollToggled)
            EVT_BUTTON(ID_PAUSE_BTN, LogTab::OnPauseToggled) EVT_CHECKBOX(ID_CONSOLE_CHECK, LogTab::OnConsoleToggled)
                EVT_CHECKBOX(ID_FILE_CHECK, LogTab::OnFileToggled) EVT_BUTTON(ID_CLEAR_BTN, LogTab::OnClearClicked)
                    EVT_BUTTON(ID_COPY_BTN, LogTab::OnCopyClicked) EVT_BUTTON(ID_EXPORT_BTN, LogTab::OnExportClicked)
                        EVT_LIST_ITEM_SELECTED(ID_LOG_LIST, LogTab::OnListItemSelected)
                            EVT_LIST_ITEM_RIGHT_CLICK(ID_LOG_LIST, LogTab::OnListItemRightClick) wxEND_EVENT_TABLE()
 
                                LogTab::LogTab(wxWindow *parent)
    : wxPanel(parent, wxID_ANY), m_levelFilter(nullptr), m_categoryFilter(nullptr), m_searchCtrl(nullptr),
      m_autoScrollCheck(nullptr), m_pauseBtn(nullptr), m_consoleCheck(nullptr), m_fileCheck(nullptr),
      m_clearBtn(nullptr), m_copyBtn(nullptr), m_exportBtn(nullptr), m_logCountLabel(nullptr), m_logList(nullptr),
      m_currentLevelFilter(EmberCore::LogLevel::All), m_currentCategoryFilter(""), m_currentSearchFilter(""),
      m_autoScroll(true), m_paused(false), m_updatingCategories(false), m_observerId(0) {
    SetBackgroundColour(wxColour(45, 45, 48));
    CreateLayout();
    SetupEventHandlers();
}
 
LogTab::~LogTab() {
    // Remove observer to prevent dangling callback
    if (m_observerId != 0) {
        EmberCore::Logger::GetInstance().RemoveObserver(m_observerId);
    }
}
 
void LogTab::Initialize() {
    // Guard against double initialization - only register observer once
    if (m_observerId != 0) {
        return; // Already initialized
    }
 
    // Load and apply settings from preferences
    LoadSettings();
 
    // Register as observer for log updates and store the ID for cleanup
    m_observerId = EmberCore::Logger::GetInstance().AddObserver([this]() {
        // Use CallAfter to ensure we're on the main thread
        CallAfter([this]() { OnLogUpdated(); });
    });
 
    // Initial load
    RefreshLogList();
}
 
void LogTab::LoadSettings() {
    auto &prefs = EmberForge::AppPreferencesManager::GetInstance().GetPreferences();
    const auto &logSettings = prefs.GetBottomPanelSettings().logTab;
 
    // Apply default level filter
    // UI order: All(0), Trace(1), Info(2), Warning(3), Error(4), Critical(5)
    // LogLevel enum: All=0, Trace=1, Info=2, Warning=3, Error=4, Critical=5
    int levelIndex = logSettings.defaultLevelFilter;
    if (levelIndex >= 0 && levelIndex < static_cast<int>(m_levelFilter->GetCount())) {
        m_levelFilter->SetSelection(levelIndex);
        m_currentLevelFilter = static_cast<EmberCore::LogLevel>(levelIndex);
    }
 
    // Apply auto-scroll setting
    m_autoScroll = logSettings.autoScrollEnabled;
    if (m_autoScrollCheck) {
        m_autoScrollCheck->SetValue(m_autoScroll);
    }
 
    // Apply console colors setting
    EmberCore::Logger::GetInstance().SetConsoleColorsEnabled(logSettings.enableConsoleColors);
 
    // Apply font size to log list
    if (m_logList) {
        wxFont font = m_logList->GetFont();
        int fontSize = static_cast<int>(logSettings.fontSize);
        font.SetPointSize(fontSize);
        m_logList->SetFont(font);
    }
}
 
void LogTab::CreateLayout() {
    wxBoxSizer *mainSizer = new wxBoxSizer(wxVERTICAL);
 
    // Create toolbar
    CreateToolbar();
 
    // Add toolbar to main sizer
    wxPanel *toolbarPanel = new wxPanel(this, wxID_ANY);
    toolbarPanel->SetBackgroundColour(wxColour(60, 60, 63));
 
    wxBoxSizer *toolbarSizer = new wxBoxSizer(wxVERTICAL);
 
    // Row 1: Filter controls
    wxBoxSizer *filterRow = new wxBoxSizer(wxHORIZONTAL);
 
    // Level filter
    wxStaticText *levelLabel = new wxStaticText(toolbarPanel, wxID_ANY, "Level:");
    levelLabel->SetForegroundColour(wxColour(200, 200, 200));
    filterRow->Add(levelLabel, 0, wxALIGN_CENTER_VERTICAL | wxLEFT | wxRIGHT, 5);
 
    wxArrayString levelChoices;
    levelChoices.Add("All");
    levelChoices.Add("Trace");
    levelChoices.Add("Info");
    levelChoices.Add("Warning");
    levelChoices.Add("Error");
    levelChoices.Add("Critical");
    m_levelFilter = new wxChoice(toolbarPanel, ID_LEVEL_FILTER, wxDefaultPosition, wxSize(90, -1), levelChoices);
    m_levelFilter->SetSelection(0);
    filterRow->Add(m_levelFilter, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    // Category filter
    wxStaticText *categoryLabel = new wxStaticText(toolbarPanel, wxID_ANY, "Category:");
    categoryLabel->SetForegroundColour(wxColour(200, 200, 200));
    filterRow->Add(categoryLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
 
    m_categoryFilter = new wxComboBox(toolbarPanel, ID_CATEGORY_FILTER, "", wxDefaultPosition, wxSize(120, -1));
    m_categoryFilter->Append(""); // Empty means all categories
    filterRow->Add(m_categoryFilter, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    // Search
    m_searchCtrl = new wxSearchCtrl(toolbarPanel, ID_SEARCH_CTRL, "", wxDefaultPosition, wxSize(150, -1));
    m_searchCtrl->SetDescriptiveText("Search logs...");
    filterRow->Add(m_searchCtrl, 1, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    // Auto-scroll checkbox
    m_autoScrollCheck = new wxCheckBox(toolbarPanel, ID_AUTO_SCROLL, "Auto-scroll");
    m_autoScrollCheck->SetForegroundColour(wxColour(200, 200, 200));
    m_autoScrollCheck->SetValue(true);
    filterRow->Add(m_autoScrollCheck, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    // Pause/Play button
    m_pauseBtn = new wxButton(toolbarPanel, ID_PAUSE_BTN, "Pause", wxDefaultPosition, wxSize(60, -1));
    UpdatePauseButtonAppearance();
    filterRow->Add(m_pauseBtn, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
 
    toolbarSizer->Add(filterRow, 0, wxEXPAND | wxALL, 3);
 
    // Row 2: Log control and actions
    wxBoxSizer *controlRow = new wxBoxSizer(wxHORIZONTAL);
 
    // Console toggle
    m_consoleCheck = new wxCheckBox(toolbarPanel, ID_CONSOLE_CHECK, "Console");
    m_consoleCheck->SetForegroundColour(wxColour(200, 200, 200));
    m_consoleCheck->SetValue(EmberCore::Logger::GetInstance().IsConsoleLoggingEnabled());
    controlRow->Add(m_consoleCheck, 0, wxALIGN_CENTER_VERTICAL | wxLEFT | wxRIGHT, 5);
 
    // File toggle
    m_fileCheck = new wxCheckBox(toolbarPanel, ID_FILE_CHECK, "File");
    m_fileCheck->SetForegroundColour(wxColour(200, 200, 200));
    m_fileCheck->SetValue(EmberCore::Logger::GetInstance().IsFileLoggingEnabled());
    controlRow->Add(m_fileCheck, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    // Separator
    controlRow->Add(new wxStaticLine(toolbarPanel, wxID_ANY, wxDefaultPosition, wxSize(1, 20), wxLI_VERTICAL), 0,
                    wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    // Action buttons
    m_clearBtn = new wxButton(toolbarPanel, ID_CLEAR_BTN, "Clear", wxDefaultPosition, wxSize(60, -1));
    controlRow->Add(m_clearBtn, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
 
    m_copyBtn = new wxButton(toolbarPanel, ID_COPY_BTN, "Copy", wxDefaultPosition, wxSize(60, -1));
    controlRow->Add(m_copyBtn, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
 
    m_exportBtn = new wxButton(toolbarPanel, ID_EXPORT_BTN, "Export", wxDefaultPosition, wxSize(60, -1));
    controlRow->Add(m_exportBtn, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
 
    controlRow->AddStretchSpacer();
 
    // Log count display (right-aligned)
    m_logCountLabel = new wxStaticText(toolbarPanel, wxID_ANY, "Showing 0 of 0 logs");
    m_logCountLabel->SetForegroundColour(wxColour(150, 150, 150));
    controlRow->Add(m_logCountLabel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    toolbarSizer->Add(controlRow, 0, wxEXPAND | wxALL, 3);
 
    toolbarPanel->SetSizer(toolbarSizer);
    mainSizer->Add(toolbarPanel, 0, wxEXPAND);
 
    // Create log list
    CreateLogList();
    mainSizer->Add(m_logList, 1, wxEXPAND | wxALL, 2);
 
    SetSizer(mainSizer);
}
 
void LogTab::CreateToolbar() {
    // Toolbar is created inline in CreateLayout
}
 
void LogTab::CreateLogList() {
    // Use virtual list for efficient handling of large log counts
    // The VirtualLogListCtrl only renders visible rows, making it fast even with 10000+ logs
    m_logList = new VirtualLogListCtrl(this, ID_LOG_LIST, this);
}
 
void LogTab::SetupEventHandlers() {
    // Event handlers are set up via event table
}
 
void LogTab::RefreshLogList() {
    // Get filtered entries from Logger
    auto &logger = EmberCore::Logger::GetInstance();
    m_filteredEntries = logger.GetFilteredEntries(m_currentLevelFilter, m_currentCategoryFilter.ToStdString(),
                                                  m_currentSearchFilter.ToStdString());
 
    // Update category choices
    UpdateCategoryChoices();
 
    // Populate list
    PopulateList(m_filteredEntries);
 
    // Update log count display
    UpdateLogCountDisplay();
 
    // Auto-scroll if enabled
    if (m_autoScroll && m_logList->GetItemCount() > 0) {
        ScrollToBottom();
    }
}
 
void LogTab::PopulateList(const std::vector<std::shared_ptr<EmberCore::LogEntry>> &entries) {
    // Virtual list magic: instead of inserting 1000 items one by one,
    // we just tell the list "there are 1000 items" and it asks for data
    // only when it needs to display a row (typically ~15-20 visible rows)
    m_logList->SetEntries(&m_filteredEntries);
    m_logList->Refresh();
}
 
void LogTab::UpdateCategoryChoices() {
    // Set guard flag to prevent recursive event handling
    m_updatingCategories = true;
 
    auto &logger = EmberCore::Logger::GetInstance();
    const auto &entries = logger.GetEntries();
 
    // Collect unique categories
    for (const auto &entry : entries) {
        m_knownCategories.insert(entry->category);
    }
 
    // Save current selection
    wxString currentSelection = m_categoryFilter->GetValue();
 
    // Update choices
    m_categoryFilter->Clear();
    m_categoryFilter->Append(""); // All categories
    for (const auto &category : m_knownCategories) {
        m_categoryFilter->Append(wxString(category));
    }
 
    // Restore selection
    int idx = m_categoryFilter->FindString(currentSelection);
    if (idx != wxNOT_FOUND) {
        m_categoryFilter->SetSelection(idx);
    } else {
        m_categoryFilter->SetValue(currentSelection);
    }
 
    // Clear guard flag
    m_updatingCategories = false;
}
 
wxString LogTab::FormatTimestamp(const std::chrono::system_clock::time_point &timestamp) const {
    auto time = std::chrono::system_clock::to_time_t(timestamp);
    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(timestamp.time_since_epoch()) % 1000;
 
    std::tm tm_buf;
#ifdef _WIN32
    localtime_s(&tm_buf, &time);
#else
    localtime_r(&time, &tm_buf);
#endif
 
    std::ostringstream oss;
    oss << std::put_time(&tm_buf, "%H:%M:%S") << "." << std::setfill('0') << std::setw(3) << ms.count();
    return wxString(oss.str());
}
 
wxColour LogTab::GetLevelColor(EmberCore::LogLevel level) const {
    auto &prefs = EmberForge::AppPreferencesManager::GetInstance().GetPreferences();
    const auto &logSettings = prefs.GetBottomPanelSettings().logTab;
 
    // If GUI colors are disabled, return default text color
    if (!logSettings.enableGuiColors) {
        return wxColour(220, 220, 220); // Default light gray text
    }
 
    // Return configured colors based on log level
    switch (level) {
    case EmberCore::LogLevel::Trace:
        return wxColour(logSettings.traceColor.r, logSettings.traceColor.g, logSettings.traceColor.b);
    case EmberCore::LogLevel::Info:
        return wxColour(logSettings.infoColor.r, logSettings.infoColor.g, logSettings.infoColor.b);
    case EmberCore::LogLevel::Warning:
        return wxColour(logSettings.warningColor.r, logSettings.warningColor.g, logSettings.warningColor.b);
    case EmberCore::LogLevel::Error:
        return wxColour(logSettings.errorColor.r, logSettings.errorColor.g, logSettings.errorColor.b);
    case EmberCore::LogLevel::Critical:
        return wxColour(logSettings.criticalColor.r, logSettings.criticalColor.g, logSettings.criticalColor.b);
    default:
        return wxColour(200, 200, 200); // Light gray
    }
}
 
wxString LogTab::GetLevelString(EmberCore::LogLevel level) const {
    switch (level) {
    case EmberCore::LogLevel::Trace:
        return "TRACE";
    case EmberCore::LogLevel::Info:
        return "INFO";
    case EmberCore::LogLevel::Warning:
        return "WARNING";
    case EmberCore::LogLevel::Error:
        return "ERROR";
    case EmberCore::LogLevel::Critical:
        return "CRITICAL";
    default:
        return "ALL";
    }
}
 
void LogTab::ScrollToBottom() {
    if (m_logList && m_logList->GetItemCount() > 0) {
        m_logList->EnsureVisible(m_logList->GetItemCount() - 1);
    }
}
 
void LogTab::Refresh() {
    // Reload settings in case they changed
    LoadSettings();
 
    // Refresh the log list
    RefreshLogList();
}
 
void LogTab::OnActivated() { RefreshLogList(); }
 
void LogTab::OnDeactivated() {
    // Nothing specific needed
}
 
void LogTab::OnClosed() {
    // Remove observer IMMEDIATELY when tab is closed to prevent dangling callback
    // This is called before the tab is destroyed, ensuring no callbacks fire on destroyed object
    if (m_observerId != 0) {
        EmberCore::Logger::GetInstance().RemoveObserver(m_observerId);
        m_observerId = 0; // Mark as removed
    }
}
 
// Filter methods
void LogTab::SetLevelFilter(EmberCore::LogLevel level) {
    m_currentLevelFilter = level;
    RefreshLogList();
}
 
void LogTab::SetCategoryFilter(const wxString &category) {
    m_currentCategoryFilter = category;
    RefreshLogList();
}
 
void LogTab::SetSearchFilter(const wxString &searchText) {
    m_currentSearchFilter = searchText;
    RefreshLogList();
}
 
void LogTab::ClearFilters() {
    m_currentLevelFilter = EmberCore::LogLevel::All;
    m_currentCategoryFilter = "";
    m_currentSearchFilter = "";
 
    m_levelFilter->SetSelection(0);
    m_categoryFilter->SetValue("");
    m_searchCtrl->SetValue("");
 
    RefreshLogList();
}
 
// Log control methods
void LogTab::SetConsoleLoggingEnabled(bool enabled) {
    EmberCore::Logger::GetInstance().SetConsoleLoggingEnabled(enabled);
}
 
void LogTab::SetFileLoggingEnabled(bool enabled) { EmberCore::Logger::GetInstance().SetFileLoggingEnabled(enabled); }
 
// Actions
void LogTab::ClearLogs() {
    EmberCore::Logger::GetInstance().ClearEntries();
    m_knownCategories.clear();
    RefreshLogList();
}
 
void LogTab::CopySelectedToClipboard() {
    long selectedIdx = m_logList->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
    if (selectedIdx == -1) {
        // No selection, copy all visible logs
        wxString allLogs;
        for (size_t i = 0; i < m_filteredEntries.size(); ++i) {
            const auto &entry = m_filteredEntries[i];
            allLogs +=
                wxString::Format("[%s] [%s] [%s] %s\n", FormatTimestamp(entry->timestamp), GetLevelString(entry->level),
                                 wxString(entry->category), wxString(entry->message));
        }
 
        if (wxTheClipboard->Open()) {
            wxTheClipboard->SetData(new wxTextDataObject(allLogs));
            wxTheClipboard->Close();
        }
    } else {
        // Copy selected entry
        if (selectedIdx < static_cast<long>(m_filteredEntries.size())) {
            const auto &entry = m_filteredEntries[selectedIdx];
            wxString logText =
                wxString::Format("[%s] [%s] [%s] %s", FormatTimestamp(entry->timestamp), GetLevelString(entry->level),
                                 wxString(entry->category), wxString(entry->message));
 
            if (wxTheClipboard->Open()) {
                wxTheClipboard->SetData(new wxTextDataObject(logText));
                wxTheClipboard->Close();
            }
        }
    }
}
 
void LogTab::ExportLogs() {
    wxFileDialog saveDialog(this, "Export Logs", "", "logs.txt",
                            "Text files (*.txt)|*.txt|Log files (*.log)|*.log|All files (*.*)|*.*",
                            wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
 
    if (saveDialog.ShowModal() == wxID_CANCEL) {
        return;
    }
 
    wxString filepath = saveDialog.GetPath();
    std::ofstream file(filepath.ToStdString());
 
    if (!file.is_open()) {
        wxMessageBox("Failed to open file for writing.", "Export Error", wxOK | wxICON_ERROR);
        return;
    }
 
    // Export all entries (not just filtered)
    auto &logger = EmberCore::Logger::GetInstance();
    const auto &entries = logger.GetEntries();
 
    for (const auto &entry : entries) {
        file << "[" << FormatTimestamp(entry->timestamp).ToStdString() << "] "
             << "[" << GetLevelString(entry->level).ToStdString() << "] "
             << "[" << entry->category << "] " << entry->message << "\n";
    }
 
    file.close();
 
    LOG_INFO("LogTab", "Exported " + std::to_string(entries.size()) + " log entries to " + filepath.ToStdString());
}
 
// Event handlers
void LogTab::OnLevelFilterChanged(wxCommandEvent &event) {
    int selection = m_levelFilter->GetSelection();
    m_currentLevelFilter = static_cast<EmberCore::LogLevel>(selection);
    RefreshLogList();
}
 
void LogTab::OnCategoryFilterChanged(wxCommandEvent &event) {
    // Prevent recursive calls when UpdateCategoryChoices modifies the combobox
    if (m_updatingCategories) {
        return;
    }
 
    m_currentCategoryFilter = m_categoryFilter->GetValue();
    RefreshLogList();
}
 
void LogTab::OnSearchTextChanged(wxCommandEvent &event) {
    m_currentSearchFilter = m_searchCtrl->GetValue();
    RefreshLogList();
}
 
void LogTab::OnAutoScrollToggled(wxCommandEvent &event) {
    m_autoScroll = m_autoScrollCheck->GetValue();
    if (m_autoScroll) {
        ScrollToBottom();
    }
}
 
void LogTab::OnConsoleToggled(wxCommandEvent &event) { SetConsoleLoggingEnabled(m_consoleCheck->GetValue()); }
 
void LogTab::OnFileToggled(wxCommandEvent &event) { SetFileLoggingEnabled(m_fileCheck->GetValue()); }
 
void LogTab::OnClearClicked(wxCommandEvent &event) { ClearLogs(); }
 
void LogTab::OnCopyClicked(wxCommandEvent &event) { CopySelectedToClipboard(); }
 
void LogTab::OnExportClicked(wxCommandEvent &event) { ExportLogs(); }
 
void LogTab::OnListItemSelected(wxListEvent &event) {
    // Could show detailed log info in a status bar or detail panel
}
 
void LogTab::OnListItemRightClick(wxListEvent &event) {
    wxMenu menu;
    menu.Append(wxID_COPY, "Copy");
    menu.Append(wxID_CLEAR, "Clear All");
 
    int id = GetPopupMenuSelectionFromUser(menu);
    if (id == wxID_COPY) {
        CopySelectedToClipboard();
    } else if (id == wxID_CLEAR) {
        ClearLogs();
    }
}
 
void LogTab::OnLogUpdated() {
    // Don't update if paused
    if (m_paused) {
        return;
    }
    RefreshLogList();
}
 
void LogTab::OnPauseToggled(wxCommandEvent &event) {
    m_paused = !m_paused;
    UpdatePauseButtonAppearance();
 
    // If resuming, refresh to show any logs that came in while paused
    if (!m_paused) {
        RefreshLogList();
    }
}
 
void LogTab::UpdatePauseButtonAppearance() {
    if (m_paused) {
        // Paused state - green background, "Play" text
        m_pauseBtn->SetLabel("Play");
        m_pauseBtn->SetBackgroundColour(wxColour(60, 140, 60)); // Green
        m_pauseBtn->SetForegroundColour(wxColour(255, 255, 255));
    } else {
        // Playing state - red background, "Pause" text
        m_pauseBtn->SetLabel("Pause");
        m_pauseBtn->SetBackgroundColour(wxColour(180, 60, 60)); // Red
        m_pauseBtn->SetForegroundColour(wxColour(255, 255, 255));
    }
    m_pauseBtn->Refresh();
}
 
void LogTab::UpdateLogCountDisplay() {
    size_t filteredCount = m_filteredEntries.size();
    size_t totalCount = EmberCore::Logger::GetInstance().GetEntries().size();
 
    // Always show "X of Y" format
    wxString label = wxString::Format("Showing %zu of %zu logs", filteredCount, totalCount);
 
    m_logCountLabel->SetLabel(label);
}
 
} // namespace EmberForge