SidePanel.cpp

Go to the documentation of this file.

#include "Components/SidePanel.h"
 
#include <algorithm>
#include <wx/sizer.h>
 
namespace EmberUI {
 
wxBEGIN_EVENT_TABLE(SidePanel, Panel) EVT_AUINOTEBOOK_PAGE_CHANGED(SidePanel::ID_NOTEBOOK, SidePanel::OnTabChanged)
    EVT_AUINOTEBOOK_PAGE_CLOSE(SidePanel::ID_NOTEBOOK, SidePanel::OnTabClosed) wxEND_EVENT_TABLE()
 
        SidePanel::SidePanel(wxWindow *parent, const wxString &panelName, bool autoLayout)
    : Panel(parent, panelName), m_notebook(nullptr), m_activeTabIndex(-1) {
    SetPanelType("SidePanel");
    if (autoLayout) {
        CreateLayout();
    }
}
 
SidePanel::~SidePanel() {
    if (m_notebook) {
        while (m_notebook->GetPageCount() > 0) {
            m_notebook->RemovePage(0);
        }
    }
}
 
void SidePanel::CreateLayout() {
    wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
 
    CreateNotebook();
 
    if (m_notebook) {
        sizer->Add(m_notebook, 1, wxEXPAND | wxALL, 2);
    }
 
    SetMainSizer(sizer);
}
 
void SidePanel::CreateNotebook() {
    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 wxAuiNotebook(this, ID_NOTEBOOK, wxDefaultPosition, wxDefaultSize, style);
}
 
int SidePanel::AddTab(ITabPtr tab) {
    if (!tab || !m_notebook) {
        return -1;
    }
 
    wxWindow *widget = tab->GetWidget();
    wxString title = tab->GetTitle();
 
    bool ok = m_notebook->AddPage(widget, title, true);
    int index = ok ? static_cast<int>(m_notebook->GetPageCount()) - 1 : -1;
 
    if (ok) {
        tab->Initialize();
        ITab *rawTab = tab.get();
        m_tabs.push_back(std::move(tab));
        m_activeTabIndex = index;
        OnTabAdded(rawTab, index);
    }
 
    return index;
}
 
ITabPtr SidePanel::RemoveTab(int index) {
    if (index < 0 || index >= static_cast<int>(m_tabs.size()) || !m_notebook) {
        return nullptr;
    }
 
    if (!m_notebook->RemovePage(index)) {
        return nullptr;
    }
 
    ITabPtr removed = std::move(m_tabs[index]);
    m_tabs.erase(m_tabs.begin() + index);
 
    if (removed) {
        removed->OnClosed();
        OnTabRemoved(removed.get(), index);
    }
 
    if (m_activeTabIndex == index) {
        m_activeTabIndex = m_tabs.empty() ? -1 : std::min(m_activeTabIndex, static_cast<int>(m_tabs.size()) - 1);
    } else if (m_activeTabIndex > index) {
        --m_activeTabIndex;
    }
 
    return removed;
}
 
ITab *SidePanel::GetTab(int index) const {
    if (index < 0 || index >= static_cast<int>(m_tabs.size())) {
        return nullptr;
    }
    return m_tabs[index].get();
}
 
ITab *SidePanel::GetActiveTab() const {
    if (m_activeTabIndex < 0 || m_activeTabIndex >= static_cast<int>(m_tabs.size())) {
        return nullptr;
    }
    return m_tabs[m_activeTabIndex].get();
}
 
bool SidePanel::SetActiveTab(int index) {
    if (index < 0 || index >= static_cast<int>(m_tabs.size()) || !m_notebook) {
        return false;
    }
    m_notebook->SetSelection(index);
    m_activeTabIndex = index;
    return true;
}
 
bool SidePanel::HasTabWithName(const wxString &name) const {
    for (const auto &tab : m_tabs) {
        if (tab && tab->GetTitle() == name) {
            return true;
        }
    }
    return false;
}
 
void SidePanel::ClearAllTabs() {
    if (!m_notebook) {
        return;
    }
    while (m_notebook->GetPageCount() > 0) {
        RemoveTab(0);
    }
    m_activeTabIndex = -1;
}
 
void SidePanel::OnTabAdded(ITab *, int) {}
void SidePanel::OnTabRemoved(ITab *, int) {}
void SidePanel::OnActiveTabChanged(ITab *, int) {}
 
void SidePanel::OnTabChanged(wxAuiNotebookEvent &event) {
    int sel = event.GetSelection();
    if (sel != wxNOT_FOUND) {
        m_activeTabIndex = sel;
        ITab *tab = GetTab(sel);
        if (tab) {
            OnActiveTabChanged(tab, sel);
        }
    }
    event.Skip();
}
 
void SidePanel::OnTabClosed(wxAuiNotebookEvent &event) {
    int closedIndex = event.GetSelection();
 
    if (closedIndex >= 0 && closedIndex < static_cast<int>(m_tabs.size())) {
        if (m_tabs[closedIndex]) {
            m_tabs[closedIndex]->OnClosed();
            OnTabRemoved(m_tabs[closedIndex].get(), closedIndex);
        }
        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;
            }
        }
    });
 
    event.Skip();
}
 
} // namespace EmberUI