CustomTabArt.cpp

Go to the documentation of this file.

#include "Utils/CustomTabArt.h"
#include "Utils/AppPreferences.h"
#include "Utils/ResourcePath.h"
#include <wx/dcgraph.h>
 
namespace EmberForge {
 
// Define the custom events
wxDEFINE_EVENT(EVT_TAB_ART_ADD_BUTTON, wxCommandEvent);
wxDEFINE_EVENT(EVT_TAB_ART_MENU_BUTTON, wxCommandEvent);
 
CustomTabArt::CustomTabArt()
    : wxAuiFlatTabArt(), m_hoveredButton(TabBarButton::None), m_pressedButton(TabBarButton::None),
      m_buttonsEnabled(true), m_iconsLoaded(false) {
    // Initialize with the current accent color
    UpdateAccentColor();
}
 
wxAuiTabArt *CustomTabArt::Clone() {
    CustomTabArt *art = new CustomTabArt();
    art->SetNormalFont(m_normalFont);
    art->SetSelectedFont(m_selectedFont);
    art->SetMeasuringFont(m_measuringFont);
    art->m_accentColor = m_accentColor;
 
    // Copy button state
    art->m_plusNormal = m_plusNormal;
    art->m_plusHovered = m_plusHovered;
    art->m_plusPressed = m_plusPressed;
    art->m_menuNormal = m_menuNormal;
    art->m_menuHovered = m_menuHovered;
    art->m_menuPressed = m_menuPressed;
    art->m_buttonsEnabled = m_buttonsEnabled;
    art->m_iconsLoaded = m_iconsLoaded;
 
    return art;
}
 
void CustomTabArt::UpdateAccentColor() {
    // Get the accent color from preferences
    m_accentColor = AppPreferencesManager::GetAccentColor();
}
 
int CustomTabArt::GetIndentSize() {
    // Return a larger indent to accommodate bigger buttons
    return 8;
}
 
int CustomTabArt::GetBestTabCtrlSize(wxWindow *wnd, const wxAuiNotebookPageArray &pages,
                                     const wxSize &requiredBmpSize) {
    // Get the base size from parent
    int baseSize = wxAuiFlatTabArt::GetBestTabCtrlSize(wnd, pages, requiredBmpSize);
 
    // Ensure minimum height to accommodate our 36px buttons plus some padding
    const int MIN_TAB_HEIGHT = 42;
 
    return std::max(baseSize, MIN_TAB_HEIGHT);
}
 
void CustomTabArt::LoadButtonIcons() {
    if (m_iconsLoaded) {
        return;
    }
 
    // Load plus button icons
    wxString plusIconPath = ResourcePath::GetDir("buttons/plus");
    m_plusNormal = wxBitmap(plusIconPath + "Plus_Normal_20.png", wxBITMAP_TYPE_PNG);
    m_plusHovered = wxBitmap(plusIconPath + "Plus_Hovered_20.png", wxBITMAP_TYPE_PNG);
    m_plusPressed = wxBitmap(plusIconPath + "Plus_Pressed_20.png", wxBITMAP_TYPE_PNG);
 
    // Load menu button icons
    wxString menuIconPath = ResourcePath::GetDir("buttons/menu");
    m_menuNormal = wxBitmap(menuIconPath + "Menu_Normal_20.png", wxBITMAP_TYPE_PNG);
    m_menuHovered = wxBitmap(menuIconPath + "Menu_Hovered_20.png", wxBITMAP_TYPE_PNG);
    m_menuPressed = wxBitmap(menuIconPath + "Menu_Pressed_20.png", wxBITMAP_TYPE_PNG);
 
    m_iconsLoaded = true;
}
 
int CustomTabArt::DrawPageTab(wxDC &dc, wxWindow *wnd, wxAuiNotebookPage &page, const wxRect &rect) {
    UpdateAccentColor();
 
    bool isNonClosable = page.window && page.window->GetName() == "BlackboardScene";
 
    std::vector<wxAuiTabContainerButton> savedButtons;
    if (isNonClosable) {
        savedButtons = std::move(page.buttons);
        page.buttons.clear();
    }
 
    int result = wxAuiFlatTabArt::DrawPageTab(dc, wnd, page, rect);
 
    if (isNonClosable) {
        page.buttons = std::move(savedButtons);
    }
 
    const int THICKNESS = wnd->FromDIP(2);
    const int y = m_flags & wxAUI_NB_BOTTOM ? page.rect.GetBottom() - THICKNESS : page.rect.GetTop();
 
    if (isNonClosable) {
        wxColour bbColor(150, 100, 200);
        dc.SetBrush(wxBrush(bbColor));
        dc.SetPen(*wxTRANSPARENT_PEN);
        dc.DrawRectangle(page.rect.GetLeft() + 1, y, page.rect.GetWidth() - 1, THICKNESS);
    } else if (page.active) {
        dc.SetBrush(wxBrush(m_accentColor));
        dc.SetPen(*wxTRANSPARENT_PEN);
        dc.DrawRectangle(page.rect.GetLeft() + 1, y, page.rect.GetWidth() - 1, THICKNESS);
    }
 
    return result;
}
 
int CustomTabArt::GetButtonAreaWidth() const {
    if (!m_buttonsEnabled) {
        return 0;
    }
    // Two buttons + spacing + margins
    return (BUTTON_SIZE * 2) + BUTTON_SPACING + (BUTTON_MARGIN * 2);
}
 
void CustomTabArt::DrawTabBarButtons(wxDC &dc, wxWindow *wnd, const wxRect &rect) {
    if (!m_buttonsEnabled || !m_iconsLoaded) {
        return;
    }
 
    // Calculate button positions at the right side of the tab bar
    int tabHeight = rect.GetHeight();
    int buttonY = rect.GetTop() + (tabHeight - BUTTON_SIZE) / 2;
 
    // Menu button is at the far right
    int menuX = rect.GetRight() - BUTTON_MARGIN - BUTTON_SIZE;
    m_menuButtonRect = wxRect(menuX, buttonY, BUTTON_SIZE, BUTTON_SIZE);
 
    // Plus button is to the left of menu button
    int plusX = menuX - BUTTON_SPACING - BUTTON_SIZE;
    m_plusButtonRect = wxRect(plusX, buttonY, BUTTON_SIZE, BUTTON_SIZE);
 
    // Select appropriate bitmap based on state for plus button
    wxBitmap plusBmp;
    if (m_pressedButton == TabBarButton::AddTab && m_plusPressed.IsOk()) {
        plusBmp = m_plusPressed;
    } else if (m_hoveredButton == TabBarButton::AddTab && m_plusHovered.IsOk()) {
        plusBmp = m_plusHovered;
    } else if (m_plusNormal.IsOk()) {
        plusBmp = m_plusNormal;
    }
 
    // Select appropriate bitmap based on state for menu button
    wxBitmap menuBmp;
    if (m_pressedButton == TabBarButton::Menu && m_menuPressed.IsOk()) {
        menuBmp = m_menuPressed;
    } else if (m_hoveredButton == TabBarButton::Menu && m_menuHovered.IsOk()) {
        menuBmp = m_menuHovered;
    } else if (m_menuNormal.IsOk()) {
        menuBmp = m_menuNormal;
    }
 
    // Draw the buttons
    if (plusBmp.IsOk()) {
        dc.DrawBitmap(plusBmp, m_plusButtonRect.GetLeft(), m_plusButtonRect.GetTop(), true);
    }
    if (menuBmp.IsOk()) {
        dc.DrawBitmap(menuBmp, m_menuButtonRect.GetLeft(), m_menuButtonRect.GetTop(), true);
    }
}
 
TabBarButton CustomTabArt::ButtonHitTest(int x, int y) const {
    if (!m_buttonsEnabled) {
        return TabBarButton::None;
    }
 
    if (m_plusButtonRect.Contains(x, y)) {
        return TabBarButton::AddTab;
    }
    if (m_menuButtonRect.Contains(x, y)) {
        return TabBarButton::Menu;
    }
    return TabBarButton::None;
}
 
void CustomTabArt::SetHoveredButton(TabBarButton button) { m_hoveredButton = button; }
 
void CustomTabArt::SetPressedButton(TabBarButton button) { m_pressedButton = button; }
 
} // namespace EmberForge