SidePanel.cpp

Go to the documentation of this file.

#include "App/MainFrame.h"
#include "Components/ForgeSidePanel.h"
#include "Components/TabFactory.h"
#include "Dialogs/PreferencesDialog.h"
#include "Utils/AppPreferences.h"
#include "Utils/CustomAuiNotebook.h"
#include "Utils/CustomTabArt.h"
#include "Utils/Logger.h"
#include "Utils/ResourcePath.h"
#include <algorithm>
#include <ctime>
#include <fstream>
#include <typeinfo>
#include <wx/artprov.h>
#include <wx/bmpbuttn.h>
#include <wx/filename.h>
#include <wx/menu.h>
#include <wx/sizer.h>
 
#ifdef HAVE_WXSVG
#include <wxSVG/imagsvg.h>
#include <wxSVG/svg.h>
#endif
 
wxBEGIN_EVENT_TABLE(SidePanel, EmberUI::SidePanel) EVT_AUINOTEBOOK_PAGE_CHANGED(SidePanel::ID_BASE_NOTEBOOK,
                                                                                SidePanel::OnTabChanged)
    EVT_AUINOTEBOOK_PAGE_CLOSE(SidePanel::ID_BASE_NOTEBOOK, SidePanel::OnTabClosed)
        EVT_MENU(SidePanel::ID_BASE_HIDE_PANEL_MENU_ITEM, SidePanel::OnHidePanelClicked)
            EVT_MENU(SidePanel::ID_BASE_PREFERENCES_MENU_ITEM, SidePanel::OnPanelPreferencesClicked) wxEND_EVENT_TABLE()
 
                SidePanel::SidePanel(wxWindow *parent, MainFrame *mainFrame, const wxString &panelName,
                                     EmberForge::PanelType panelType, EmberForge::PanelDescriptor *parentDescriptor)
    : EmberUI::SidePanel(parent, panelName, false), m_mainFrame(mainFrame), m_panelName(panelName),
      m_tabBarButtonsEnabled(true), m_isInitializing(true),
      m_descriptor(panelType, parentDescriptor ? parentDescriptor->GetHierarchyLevel() + 1 : 0, parentDescriptor) {
    LOG_INFO("Panel", std::string("Creating side panel: ") + m_panelName.ToStdString() +
                          " (Type: " + m_descriptor.GetDisplayName().ToStdString() +
                          ", Level: " + std::to_string(m_descriptor.GetHierarchyLevel()) + ")");
    DoCreateLayout();
}
 
SidePanel::~SidePanel() {
    LOG_INFO("Panel", std::string("Destroying side panel: ") + m_panelName.ToStdString());
 
    if (m_notebook) {
        while (m_notebook->GetPageCount() > 0) {
            m_notebook->RemovePage(0);
        }
    }
}
 
void SidePanel::CreateLayout() { DoCreateLayout(); }
 
void SidePanel::DoCreateLayout() {
    wxBoxSizer *mainSizer = new wxBoxSizer(wxVERTICAL);
 
    DoCreateNotebook();
    DoSetupEventHandlers();
 
    if (m_notebook) {
        mainSizer->Add(m_notebook, 1, wxEXPAND | wxALL, 2);
    }
 
    SetSizer(mainSizer);
 
    LOG_INFO("Panel", std::string("Layout created for side panel: ") + m_panelName.ToStdString());
}
 
void SidePanel::FinishSetup() {
    LOG_INFO("Panel", std::string("Calling OnPanelSpecificSetup() for ") + m_panelName.ToStdString() +
                          " (type: " + std::string(typeid(*this).name()) + ")");
    OnPanelSpecificSetup();
    LOG_INFO("Panel", std::string("OnPanelSpecificSetup() completed for ") + m_panelName.ToStdString());
 
    if (m_notebook) {
        LOG_INFO("Panel", std::string("Notebook has ") + std::to_string(m_notebook->GetPageCount()) +
                              " pages after OnPanelSpecificSetup()");
    }
}
 
void SidePanel::CreateNotebook() { DoCreateNotebook(); }
 
void SidePanel::DoCreateNotebook() {
    long style = wxAUI_NB_DEFAULT_STYLE;
    style &= ~wxAUI_NB_TAB_MOVE;
    style &= ~wxAUI_NB_TAB_EXTERNAL_MOVE;
    style &= ~wxAUI_NB_TAB_SPLIT;
 
    m_notebook = new EmberForge::CustomAuiNotebook(this, ID_BASE_NOTEBOOK, wxDefaultPosition, wxDefaultSize, style);
 
    Bind(EmberForge::EVT_TAB_ART_ADD_BUTTON, &SidePanel::OnTabBarAddButtonClicked, this);
    Bind(EmberForge::EVT_TAB_ART_MENU_BUTTON, &SidePanel::OnTabBarMenuButtonClicked, this);
 
    LOG_TRACE("Panel", std::string("Created CustomAuiNotebook for ") + m_panelName.ToStdString() +
                           " with integrated tab bar buttons");
}
 
void SidePanel::SetupEventHandlers() { DoSetupEventHandlers(); }
 
void SidePanel::DoSetupEventHandlers() {
    LOG_TRACE("Panel", std::string("Event handlers set up for %s") + m_panelName.ToStdString());
}
 
void SidePanel::OnPanelSpecificSetup() {
    LOG_INFO("Panel", std::string("Base OnPanelSpecificSetup() called for %s") + m_panelName.ToStdString());
}
 
void SidePanel::RestoreAndEnsureTabs() {
    LOG_INFO("Panel", std::string("*** RestoreAndEnsureTabs() called for ") + m_panelName.ToStdString() + " ***");
 
    if (GetRememberLastTab()) {
        const auto &lastOpenTabs = GetLastOpenTabs();
        if (!lastOpenTabs.empty()) {
            LOG_INFO("Panel", wxString::Format("Restoring %zu saved tabs", lastOpenTabs.size()).ToStdString());
            for (const auto &tabTypeStr : lastOpenTabs) {
                EmberForge::TabType tabType = EmberForge::TabFactory::StringToTabType(tabTypeStr);
                CreateAndAddTab(tabType);
            }
        }
    }
 
    if (!m_notebook || m_notebook->GetPageCount() == 0) {
        LOG_INFO("Panel", "No tabs exist, trying to create a default tab");
 
        auto supportedTypes = GetSupportedTabTypes();
        for (const auto &tabType : supportedTypes) {
            size_t countBefore = m_notebook ? m_notebook->GetPageCount() : 0;
            CreateAndAddTab(tabType);
            size_t countAfter = m_notebook ? m_notebook->GetPageCount() : 0;
 
            if (countAfter > countBefore) {
                LOG_INFO("Panel", wxString::Format("Created fallback tab: %s",
                                                   EmberForge::TabFactory::GetTabDisplayName(tabType))
                                      .ToStdString());
                break;
            }
        }
 
        if (m_notebook && m_notebook->GetPageCount() == 0) {
            LOG_ERROR("Panel", std::string("Failed to create any default tab for ") + m_panelName.ToStdString() +
                                   " - all supported types at max instances");
        }
    }
 
    ApplyPreferences();
 
    if (m_notebook && m_notebook->GetPageCount() > 0) {
        std::string tabToActivate = GetRememberLastTab() ? GetLastActiveTab() : GetDefaultActiveTab();
 
        EmberForge::TabType targetTabType = EmberForge::TabFactory::StringToTabType(tabToActivate);
        wxString targetTabName = EmberForge::TabFactory::GetTabDisplayName(targetTabType);
 
        int targetIndex = 0;
        for (size_t i = 0; i < m_notebook->GetPageCount(); ++i) {
            if (m_notebook->GetPageText(i) == targetTabName) {
                targetIndex = static_cast<int>(i);
                break;
            }
        }
 
        m_notebook->SetSelection(targetIndex);
        LOG_INFO("Panel", wxString::Format("Set active tab to '%s' (index %d) [rememberLastTab=%s], total tabs: %d",
                                           targetTabName, targetIndex, GetRememberLastTab() ? "true" : "false",
                                           static_cast<int>(m_notebook->GetPageCount()))
                              .ToStdString());
    }
 
    LOG_INFO("Panel", std::string("RestoreAndEnsureTabs() completed for ") + m_panelName.ToStdString());
}
 
int SidePanel::AddTab(ITabPtr tab) {
    if (!tab || !m_notebook) {
        LOG_ERROR("Panel", std::string("Cannot add null tab to %s") + m_panelName.ToStdString());
        return -1;
    }
 
    wxString tabTitle = tab->GetTitle();
 
    int index = EmberUI::SidePanel::AddTab(std::move(tab));
 
    if (index >= 0) {
        LOG_INFO("Panel", std::string("Added tab '") + tabTitle.ToStdString() + "' to " + m_panelName.ToStdString() +
                              " at index " + std::to_string(index));
        SaveState();
 
        auto &prefManager = EmberForge::AppPreferencesManager::GetInstance();
        std::string configPath = EmberForge::AppPreferences::GetDefaultConfigPath();
        if (prefManager.GetPreferences().SaveToFile(configPath)) {
            LOG_INFO("Panel", "Saved tab state to disk after tab addition");
        } else {
            LOG_ERROR("Panel", "Failed to save tab state to disk after tab addition");
        }
    } else {
        LOG_ERROR("Panel",
                  std::string("Failed to add tab '") + tabTitle.ToStdString() + "' to " + m_panelName.ToStdString());
    }
    return index;
}
 
ITabPtr SidePanel::RemoveTab(int index) {
    if (index < 0 || index >= static_cast<int>(m_tabs.size()) || !m_notebook) {
        LOG_ERROR("Panel",
                  std::string("Invalid tab index ") + std::to_string(index) + " for " + m_panelName.ToStdString());
        return nullptr;
    }
 
    ITabPtr removed = EmberUI::SidePanel::RemoveTab(index);
    if (removed) {
        LOG_INFO("Panel",
                 std::string("Removed tab at index ") + std::to_string(index) + " from " + m_panelName.ToStdString());
    } else {
        LOG_ERROR("Panel", std::string("Failed to remove tab at index ") + std::to_string(index) + " from " +
                               m_panelName.ToStdString());
    }
    return removed;
}
 
bool SidePanel::SetActiveTab(int index) {
    bool result = EmberUI::SidePanel::SetActiveTab(index);
    if (result) {
        LOG_TRACE("Panel",
                  std::string("Set active tab to index ") + std::to_string(index) + " in " + m_panelName.ToStdString());
    }
    return result;
}
 
void SidePanel::ResetToDefaultTab(EmberForge::TabType defaultTabType) {
    if (!m_notebook) {
        return;
    }
 
    wxString defaultTabName = EmberForge::TabFactory::GetTabDisplayName(defaultTabType);
    LOG_INFO("Panel", std::string("Resetting ") + m_panelName.ToStdString() +
                          " to default tab: " + defaultTabName.ToStdString());
 
    wxWindow *defaultTabWindow = nullptr;
    for (size_t i = 0; i < m_notebook->GetPageCount(); ++i) {
        if (m_notebook->GetPageText(i) == defaultTabName) {
            defaultTabWindow = m_notebook->GetPage(i);
            break;
        }
    }
 
    for (int i = static_cast<int>(m_notebook->GetPageCount()) - 1; i >= 0; --i) {
        if (m_notebook->GetPage(i) != defaultTabWindow) {
            RemoveTab(i);
        }
    }
 
    if (defaultTabWindow == nullptr) {
        CreateAndAddTab(defaultTabType);
    }
 
    if (m_notebook->GetPageCount() > 0) {
        m_notebook->SetSelection(0);
        m_activeTabIndex = 0;
    }
 
    LOG_INFO("Panel", std::string("Reset ") + m_panelName.ToStdString() +
                          " complete, tab count: " + std::to_string(m_notebook->GetPageCount()));
}
 
void SidePanel::ResetToDefaultTabs(const std::vector<EmberForge::TabType> &defaultTabTypes) {
    if (!m_notebook || defaultTabTypes.empty()) {
        return;
    }
 
    LOG_INFO("Panel", std::string("Resetting ") + m_panelName.ToStdString() + " to " +
                          std::to_string(defaultTabTypes.size()) + " default tabs");
 
    while (m_notebook->GetPageCount() > 0) {
        RemoveTab(0);
    }
 
    for (const auto &tabType : defaultTabTypes) {
        CreateAndAddTab(tabType);
    }
 
    if (m_notebook->GetPageCount() > 0) {
        m_notebook->SetSelection(0);
        m_activeTabIndex = 0;
    }
 
    LOG_INFO("Panel", std::string("Reset ") + m_panelName.ToStdString() +
                          " complete, tab count: " + std::to_string(m_notebook->GetPageCount()));
}
 
void SidePanel::ClearAllTabs() {
    if (!m_notebook) {
        return;
    }
 
    LOG_INFO("Panel", std::string("Clearing all tabs from ") + m_panelName.ToStdString());
 
    EmberUI::SidePanel::ClearAllTabs();
}
 
void SidePanel::OnTabChanged(wxAuiNotebookEvent &event) {
    int newSelection = event.GetSelection();
    if (newSelection != wxNOT_FOUND) {
        m_activeTabIndex = newSelection;
        LOG_TRACE("Panel", std::string("Tab changed to index ") + std::to_string(newSelection) + " in " +
                               m_panelName.ToStdString());
 
        SaveState();
 
        if (!m_isInitializing) {
            auto &prefManager = EmberForge::AppPreferencesManager::GetInstance();
            std::string configPath = EmberForge::AppPreferences::GetDefaultConfigPath();
            if (prefManager.GetPreferences().SaveToFile(configPath)) {
                LOG_TRACE("Panel", "Saved active tab state to disk after tab change");
            } else {
                LOG_ERROR("Panel", "Failed to save active tab state to disk after tab change");
            }
        }
    }
    event.Skip();
}
 
void SidePanel::OnTabClosed(wxAuiNotebookEvent &event) {
    int closedIndex = event.GetSelection();
    LOG_INFO("Panel", std::string("Tab at index ") + std::to_string(closedIndex) + " closed");
 
    if (closedIndex >= 0 && closedIndex < static_cast<int>(m_tabs.size())) {
        if (m_tabs[closedIndex]) {
            m_tabs[closedIndex]->OnClosed();
        }
        m_tabs[closedIndex].release();
    }
 
    CallAfter([this, closedIndex]() {
        if (closedIndex >= 0 && closedIndex < static_cast<int>(m_tabs.size())) {
            m_tabs.erase(m_tabs.begin() + closedIndex);
 
            if (m_activeTabIndex == closedIndex) {
                m_activeTabIndex =
                    m_tabs.empty() ? -1 : std::min(m_activeTabIndex, static_cast<int>(m_tabs.size()) - 1);
            } else if (m_activeTabIndex > closedIndex) {
                m_activeTabIndex--;
            }
 
            SaveState();
 
            auto &prefManager = EmberForge::AppPreferencesManager::GetInstance();
            std::string configPath = EmberForge::AppPreferences::GetDefaultConfigPath();
            if (prefManager.GetPreferences().SaveToFile(configPath)) {
                LOG_INFO("Panel", "Saved tab state to disk after tab removal");
            } else {
                LOG_ERROR("Panel", "Failed to save tab state to disk after tab removal");
            }
        }
    });
 
    event.Skip();
}
 
void SidePanel::OnAddTabButtonClickedInternal(wxCommandEvent &event) {
    LOG_INFO("Panel", std::string("Add tab button clicked in %s") + m_panelName.ToStdString());
 
    OnAddTabButtonClicked(event);
 
    if (event.GetSkipped()) {
        ShowTabCreationMenu();
    }
}
 
void SidePanel::OnTabBarAddButtonClicked(wxCommandEvent &event) {
    LOG_INFO("Panel", std::string("Tab bar add button clicked in %s") + m_panelName.ToStdString());
 
    wxCommandEvent addEvent;
    OnAddTabButtonClickedInternal(addEvent);
}
 
void SidePanel::OnTabBarMenuButtonClicked(wxCommandEvent &event) {
    LOG_INFO("Panel", std::string("Tab bar menu button clicked in %s") + m_panelName.ToStdString());
 
    wxCommandEvent menuEvent;
    OnMenuButtonClicked(menuEvent);
}
 
void SidePanel::OnMenuButtonClicked(wxCommandEvent &event) {
    LOG_INFO("Panel", std::string("Menu button clicked in %s") + m_panelName.ToStdString());
 
    wxMenu *mainMenu = new wxMenu();
 
    mainMenu->Append(ID_BASE_HIDE_PANEL_MENU_ITEM, "Hide Panel", "Hide this panel from view");
    mainMenu->AppendSeparator();
    mainMenu->Append(ID_BASE_PREFERENCES_MENU_ITEM, "Preferences...", "Open preferences for this panel");
 
    PopupMenu(mainMenu);
    delete mainMenu;
}
 
void SidePanel::OnHidePanelClicked(wxCommandEvent &event) {
    LOG_INFO("Panel", std::string("Hide panel clicked in %s") + m_panelName.ToStdString());
 
    if (!m_mainFrame) {
        LOG_ERROR("Panel", "Cannot hide panel - no MainFrame reference");
        return;
    }
 
    wxAuiManager *auiManager = m_mainFrame->GetAuiManager();
    if (!auiManager) {
        LOG_ERROR("Panel", "Cannot hide panel - no AUI manager");
        return;
    }
 
    wxString paneName = m_descriptor.GetPaneName();
 
    wxAuiPaneInfo &pane = auiManager->GetPane(paneName);
    if (pane.IsOk()) {
        pane.Hide();
        auiManager->Update();
        m_mainFrame->UpdatePanelToggleButtons();
        LOG_INFO("Panel", std::string("Panel hidden: ") + m_panelName.ToStdString());
    }
}
 
void SidePanel::OnPanelPreferencesClicked(wxCommandEvent &event) {
    LOG_INFO("Panel", std::string("Preferences clicked in %s") + m_panelName.ToStdString());
 
    if (!m_mainFrame) {
        LOG_ERROR("Panel", "Cannot open preferences - no MainFrame reference");
        return;
    }
 
    wxString sectionName = m_descriptor.GetDisplayName();
 
    PreferencesDialog dialog(m_mainFrame);
    dialog.SelectSection(sectionName);
 
    int result = dialog.ShowModal();
    if (result == wxID_OK) {
        LOG_INFO("Panel", std::string("Preferences applied for ") + m_panelName.ToStdString());
        m_mainFrame->RefreshPreferences();
    }
}
 
void SidePanel::CreateAndAddTab(EmberForge::TabType tabType) {
    if (!m_notebook || !m_mainFrame) {
        LOG_ERROR("Panel",
                  std::string("Cannot create tab - missing notebook or mainframe in %s") + m_panelName.ToStdString());
        return;
    }
 
    wxString tabName = EmberForge::TabFactory::GetTabDisplayName(tabType);
    EmberForge::PanelType panelType = m_descriptor.GetType();
 
    if (!EmberForge::TabFactory::IsTabAllowedInPanel(tabType, panelType)) {
        LOG_WARNING("Panel",
                    std::string("Tab '") + tabName.ToStdString() + "' is not allowed in " + m_panelName.ToStdString());
        return;
    }
 
    if (HasTabWithName(tabName) && !EmberForge::TabFactory::AllowMultipleInstances(tabType)) {
        LOG_WARNING("Panel",
                    std::string("Tab '") + tabName.ToStdString() + "' already exists in " + m_panelName.ToStdString());
        return;
    }
 
    int maxInstances = EmberForge::TabFactory::GetMaxGlobalInstances(tabType);
    if (maxInstances > 0) {
        int currentCount = m_mainFrame->CountTabGlobally(tabName);
        if (currentCount >= maxInstances) {
            LOG_WARNING("Panel", std::string("Tab '") + tabName.ToStdString() + "' has reached max instances (" +
                                     std::to_string(maxInstances) + ")");
            return;
        }
    }
 
    auto tab = EmberForge::TabFactory::CreateTab(tabType, m_notebook, m_mainFrame);
    if (tab) {
        AddTab(std::move(tab));
        LOG_INFO("Panel",
                 std::string("Created and added tab '") + tabName.ToStdString() + "' to " + m_panelName.ToStdString());
    } else {
        LOG_ERROR("Panel",
                  std::string("Failed to create tab '") + tabName.ToStdString() + "' for " + m_panelName.ToStdString());
    }
}
 
void SidePanel::ShowTabCreationMenu() {
    auto supportedTypes = GetSupportedTabTypes();
    if (supportedTypes.empty()) {
        LOG_WARNING("Panel", std::string("No supported tab types for %s") + m_panelName.ToStdString());
        return;
    }
 
    wxMenu menu;
    EmberForge::PanelType panelType = m_descriptor.GetType();
    int validItems = 0;
 
    for (size_t i = 0; i < supportedTypes.size(); ++i) {
        EmberForge::TabType tabType = supportedTypes[i];
 
        if (!EmberForge::TabFactory::IsTabAllowedInPanel(tabType, panelType)) {
            continue;
        }
 
        wxString displayName = EmberForge::TabFactory::GetTabDisplayName(tabType);
        wxString tooltip = EmberForge::TabFactory::GetTabTooltip(tabType);
 
        int menuId = ID_BASE_LAST + static_cast<int>(i);
        wxMenuItem *item = menu.Append(menuId, displayName, tooltip);
        validItems++;
 
        bool existsInThisPanel =
            HasTabWithName(displayName) && !EmberForge::TabFactory::AllowMultipleInstances(tabType);
 
        int maxInstances = EmberForge::TabFactory::GetMaxGlobalInstances(tabType);
        int currentCount = m_mainFrame->CountTabGlobally(displayName);
        bool atMaxInstances = (maxInstances > 0) && (currentCount >= maxInstances);
 
        if (existsInThisPanel || atMaxInstances) {
            item->Enable(false);
            if (atMaxInstances && !existsInThisPanel) {
                if (maxInstances == 1) {
                    item->SetItemLabel(displayName + " (open in another panel)");
                } else {
                    item->SetItemLabel(displayName + " (max " + std::to_string(maxInstances) + " reached)");
                }
            }
        }
 
        menu.Bind(
            wxEVT_COMMAND_MENU_SELECTED, [this, tabType](wxCommandEvent &) { CreateAndAddTab(tabType); }, menuId);
    }
 
    if (validItems == 0) {
        wxMenuItem *item = menu.Append(wxID_ANY, "(No tabs available for this panel)");
        item->Enable(false);
    }
 
    PopupMenu(&menu);
 
    LOG_TRACE("Panel", std::string("Showed tab creation menu for ") + m_panelName.ToStdString() + " with " +
                           std::to_string(validItems) + " options");
}
 
void SidePanel::SetTabBarButtonsEnabled(bool enabled) {
    if (m_tabBarButtonsEnabled == enabled) {
        return;
    }
 
    m_tabBarButtonsEnabled = enabled;
 
    if (m_notebook) {
        GetCustomNotebook()->SetTabBarButtonsEnabled(enabled);
        LOG_INFO("Panel", std::string("Tab bar buttons ") + (enabled ? "enabled" : "disabled") + " for " +
                              m_panelName.ToStdString());
    }
}
 
void SidePanel::ToggleTabBarButtons() {
    SetTabBarButtonsEnabled(!m_tabBarButtonsEnabled);
    LOG_INFO("Panel", std::string("Tab bar buttons toggled to ") + (m_tabBarButtonsEnabled ? "enabled" : "disabled") +
                          " for " + m_panelName.ToStdString());
}
 
void SidePanel::ApplyPreferences() {
    LOG_INFO("SidePanel", std::string("Base ApplyPreferences called for ") + m_panelName.ToStdString() +
                              " - derived class should override this");
}
 
void SidePanel::SaveState() {
    LOG_INFO("SidePanel", std::string("Base SaveState called for ") + m_panelName.ToStdString() +
                              " - derived class should override this");
}
 
void SidePanel::RestoreState() {
    LOG_INFO("SidePanel", std::string("Base RestoreState called for ") + m_panelName.ToStdString() +
                              " - derived class should override this");
}