TabContainer.cpp

Go to the documentation of this file.

#include "Components/TabContainer.h"
#include <algorithm>
#include <wx/menu.h>
 
namespace EmberForge {
namespace ui {
 
// Event table
wxBEGIN_EVENT_TABLE(TabContainer, wxNotebook) EVT_NOTEBOOK_PAGE_CHANGED(wxID_ANY, TabContainer::OnTabChanged)
    EVT_NOTEBOOK_PAGE_CHANGING(wxID_ANY, TabContainer::OnTabChanging) EVT_RIGHT_UP(TabContainer::OnTabRightClick)
        EVT_MIDDLE_UP(TabContainer::OnTabMiddleClick) wxEND_EVENT_TABLE()
 
            TabContainer::TabContainer(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size,
                                       long style)
    : wxNotebook(parent, id, pos, size, style), m_activeTabIndex(-1), m_allowTabReorder(true), m_showCloseButton(true) {
}
 
TabContainer::~TabContainer() { RemoveAllTabs(); }
 
int TabContainer::AddTab(std::unique_ptr<ITab> tab, const wxString &title, const wxString &tooltip) {
    if (!tab) {
        return -1;
    }
 
    // Create the tab window
    wxWindow *tabWindow = tab->GetWidget();
    if (!tabWindow) {
        return -1;
    }
 
    // Add to notebook
    int index = GetPageCount();
    if (!AddPage(tabWindow, title, true)) {
        return -1;
    }
 
    // Store tab info
    TabInfo tabInfo(std::move(tab), title);
    tabInfo.tooltip = tooltip;
    m_tabs.push_back(std::move(tabInfo));
 
    // Set tooltip if provided
    if (!tooltip.IsEmpty()) {
        // wxNotebook doesn't have SetPageToolTip in all versions
        // The tooltip functionality can be added later if needed
    }
 
    // Update active tab
    m_activeTabIndex = index;
 
    // Notify callback
    NotifyTabCreated(index);
 
    return index;
}
 
bool TabContainer::RemoveTab(int index) {
    if (!ValidateTabIndex(index)) {
        return false;
    }
 
    // Check if tab can be closed
    if (!CanCloseTab(index)) {
        return false;
    }
 
    // Notify callback before removal
    NotifyTabClosed(index);
 
    // Remove from notebook
    if (!RemovePage(index)) {
        return false;
    }
 
    // Remove from our container
    m_tabs.erase(m_tabs.begin() + index);
 
    // Update active tab index
    if (m_activeTabIndex == index) {
        m_activeTabIndex = GetPageCount() > 0 ? 0 : -1;
    } else if (m_activeTabIndex > index) {
        m_activeTabIndex--;
    }
 
    return true;
}
 
bool TabContainer::RemoveTab(ITab *tab) {
    int index = GetTabIndex(tab);
    if (index >= 0) {
        return RemoveTab(index);
    }
    return false;
}
 
void TabContainer::RemoveAllTabs() {
    while (GetTabCount() > 0) {
        RemoveTab(0);
    }
}
 
ITab *TabContainer::GetTab(int index) const {
    if (ValidateTabIndex(index)) {
        return m_tabs[index].tab.get();
    }
    return nullptr;
}
 
ITab *TabContainer::GetActiveTab() const { return GetTab(GetActiveTabIndex()); }
 
int TabContainer::GetTabCount() const { return static_cast<int>(m_tabs.size()); }
 
int TabContainer::GetTabIndex(ITab *tab) const {
    for (int i = 0; i < static_cast<int>(m_tabs.size()); ++i) {
        if (m_tabs[i].tab.get() == tab) {
            return i;
        }
    }
    return -1;
}
 
void TabContainer::SetTabTitle(int index, const wxString &title) {
    if (ValidateTabIndex(index)) {
        m_tabs[index].title = title;
        SetPageText(index, title);
    }
}
 
wxString TabContainer::GetTabTitle(int index) const {
    if (ValidateTabIndex(index)) {
        return m_tabs[index].title;
    }
    return wxEmptyString;
}
 
void TabContainer::SetTabTooltip(int index, const wxString &tooltip) {
    if (ValidateTabIndex(index)) {
        m_tabs[index].tooltip = tooltip;
        // wxNotebook doesn't have SetPageToolTip in all versions
        // The tooltip functionality can be added later if needed
    }
}
 
wxString TabContainer::GetTabTooltip(int index) const {
    if (ValidateTabIndex(index)) {
        return m_tabs[index].tooltip;
    }
    return wxEmptyString;
}
 
void TabContainer::SetTabState(int index, TabState state) {
    if (ValidateTabIndex(index)) {
        m_tabs[index].state = state;
        UpdateTabAppearance(index);
    }
}
 
TabContainer::TabState TabContainer::GetTabState(int index) const {
    if (ValidateTabIndex(index)) {
        return m_tabs[index].state;
    }
    return TabState::Inactive;
}
 
void TabContainer::SetTabClosable(int index, bool closable) {
    if (ValidateTabIndex(index)) {
        m_tabs[index].canClose = closable;
    }
}
 
bool TabContainer::IsTabClosable(int index) const {
    if (ValidateTabIndex(index)) {
        return m_tabs[index].canClose;
    }
    return false;
}
 
void TabContainer::SetActiveTab(int index) {
    if (ValidateTabIndex(index) && index != m_activeTabIndex) {
        SetSelection(index);
        m_activeTabIndex = index;
        NotifyTabActivated(index);
    }
}
 
void TabContainer::SetActiveTab(ITab *tab) {
    int index = GetTabIndex(tab);
    if (index >= 0) {
        SetActiveTab(index);
    }
}
 
int TabContainer::GetActiveTabIndex() const { return GetSelection(); }
 
void TabContainer::NextTab() {
    int current = GetActiveTabIndex();
    int next = (current + 1) % GetTabCount();
    if (next != current) {
        SetActiveTab(next);
    }
}
 
void TabContainer::PrevTab() {
    int current = GetActiveTabIndex();
    int prev = (current - 1 + GetTabCount()) % GetTabCount();
    if (prev != current) {
        SetActiveTab(prev);
    }
}
 
void TabContainer::RefreshTab(int index) {
    if (ValidateTabIndex(index)) {
        ITab *tab = m_tabs[index].tab.get();
        if (tab) {
            tab->Refresh();
        }
    }
}
 
void TabContainer::RefreshAllTabs() {
    for (int i = 0; i < GetTabCount(); ++i) {
        RefreshTab(i);
    }
}
 
bool TabContainer::CanCloseTab(int index) {
    if (!ValidateTabIndex(index)) {
        return false;
    }
 
    return m_tabs[index].canClose;
}
 
bool TabContainer::CanCloseAllTabs() {
    for (const auto &tabInfo : m_tabs) {
        if (!tabInfo.canClose) {
            return false;
        }
    }
    return true;
}
 
void TabContainer::SetTabActivatedCallback(TabActivatedCallback callback) { m_tabActivatedCallback = callback; }
 
void TabContainer::SetTabClosedCallback(TabClosedCallback callback) { m_tabClosedCallback = callback; }
 
void TabContainer::SetTabCreatedCallback(TabCreatedCallback callback) { m_tabCreatedCallback = callback; }
 
void TabContainer::SetTabUserData(int index, void *userData) {
    if (ValidateTabIndex(index)) {
        m_tabs[index].userData = userData;
    }
}
 
void *TabContainer::GetTabUserData(int index) const {
    if (ValidateTabIndex(index)) {
        return m_tabs[index].userData;
    }
    return nullptr;
}
 
bool TabContainer::SerializeState(wxString &data) const {
    // Simple serialization - can be enhanced later
    data = wxString::Format("tabs:%d,active:%d", GetTabCount(), GetActiveTabIndex());
    return true;
}
 
bool TabContainer::DeserializeState(const wxString &data) {
    // Simple deserialization - can be enhanced later
    return true;
}
 
// Event handlers
void TabContainer::OnTabChanged(wxBookCtrlEvent &event) {
    int newIndex = event.GetSelection();
    m_activeTabIndex = newIndex;
    NotifyTabActivated(newIndex);
    event.Skip();
}
 
void TabContainer::OnTabChanging(wxBookCtrlEvent &event) {
    // Allow the change by default
    event.Skip();
}
 
void TabContainer::OnTabRightClick(wxMouseEvent &event) {
    wxPoint pos = event.GetPosition();
    int hitTab = HitTest(pos);
    if (hitTab != wxNOT_FOUND) {
        CreateTabContextMenu(hitTab);
    }
    event.Skip();
}
 
void TabContainer::OnTabMiddleClick(wxMouseEvent &event) {
    wxPoint pos = event.GetPosition();
    int hitTab = HitTest(pos);
    if (hitTab != wxNOT_FOUND && CanCloseTab(hitTab)) {
        RemoveTab(hitTab);
    }
    event.Skip();
}
 
// Helper methods
void TabContainer::UpdateTabAppearance(int index) {
    if (!ValidateTabIndex(index)) {
        return;
    }
 
    // Update visual appearance based on state
    TabState state = m_tabs[index].state;
    wxString title = m_tabs[index].title;
 
    switch (state) {
    case TabState::Modified:
        SetPageText(index, title + "*");
        break;
    case TabState::Loading:
        SetPageText(index, title + "...");
        break;
    case TabState::Error:
        SetPageText(index, title + "!");
        break;
    default:
        SetPageText(index, title);
        break;
    }
}
 
void TabContainer::CreateTabContextMenu(int index) {
    if (!ValidateTabIndex(index)) {
        return;
    }
 
    wxMenu menu;
    menu.Append(wxID_CLOSE, "Close");
    menu.Append(wxID_ANY, "Close Others");
    menu.Append(wxID_ANY, "Close All");
 
    // Enable/disable based on tab properties
    menu.Enable(wxID_CLOSE, CanCloseTab(index));
 
    PopupMenu(&menu);
}
 
bool TabContainer::ValidateTabIndex(int index) const { return index >= 0 && index < static_cast<int>(m_tabs.size()); }
 
void TabContainer::NotifyTabActivated(int index) {
    if (m_tabActivatedCallback && ValidateTabIndex(index)) {
        m_tabActivatedCallback(m_tabs[index].tab.get(), index);
    }
}
 
void TabContainer::NotifyTabClosed(int index) {
    if (m_tabClosedCallback && ValidateTabIndex(index)) {
        m_tabClosedCallback(m_tabs[index].tab.get(), index);
    }
}
 
void TabContainer::NotifyTabCreated(int index) {
    if (m_tabCreatedCallback && ValidateTabIndex(index)) {
        m_tabCreatedCallback(m_tabs[index].tab.get(), index);
    }
}
 
} // namespace ui
} // namespace EmberForge