Slic3r::PluginPages Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/plugin/host/PluginPages.hpp>

Collaboration diagram for Slic3r::PluginPages:

Classes
struct	Page

Public Member Functions
	PluginPages ()=default
	~PluginPages ()
	PluginPages (const PluginPages &)=delete
PluginPages &	operator= (const PluginPages &)=delete
void	initialize (Notebook *parent)
void	shutdown ()
void	on_cap_register (const PluginCapabilityId &id)
void	on_cap_deregister (const PluginCapabilityId &id)
void	on_plugin_register (const std::string &plugin_key)
void	on_plugin_deregister (const std::string &plugin_key)
void	set_visible_page_count (int count)
void	relayout ()
void	select_page (const PluginCapabilityId &id)

Private Member Functions
std::shared_ptr< PagesPluginCapability >	get_pages_cap (const PluginCapabilityId &id, bool is_enabled) const
bool	create_page (const PluginCapabilityId &id)
void	remove_page (const PluginCapabilityId &id)
void	show_overflow_menu ()

Static Private Member Functions
static wxString	page_tab_id (const PluginCapabilityId &id)

Private Attributes
std::map< PluginCapabilityId, Page >	m_pages
std::vector< PluginCapabilityId >	m_order
Notebook *	m_parent {nullptr}
int	m_visible_page_count {0}
std::optional< PluginCapabilityId >	m_swapped_in_id
wxWindow *	m_overflow_button {nullptr}

Detailed Description

---

Class Documentation

Slic3r::PluginPages::Page

struct Slic3r::PluginPages::Page

Collaboration diagram for Slic3r::PluginPages::Page:

Class Members
wxBitmap	icon
LazyPage< PluginPage > *	page {nullptr}

Constructor & Destructor Documentation

PluginPages() [1/2]

Slic3r::PluginPages::PluginPages ( )

default

Referenced by PluginPages(), and operator=().

Here is the caller graph for this function:

~PluginPages()

Slic3r::PluginPages::~PluginPages

(

)

{
    shutdown();
}

References shutdown().

Here is the call graph for this function:

PluginPages() [2/2]

Slic3r::PluginPages::PluginPages ( const PluginPages & )

delete

References PluginPages().

Here is the call graph for this function:

Member Function Documentation

create_page()

bool Slic3r::PluginPages::create_page ( const PluginCapabilityId & id )

private

{
    if (m_pages.find(id) != m_pages.end())
        return false;
 
    auto capability = get_pages_cap(id, true);
    if (!capability)
        return false;
 
    std::string icon;
    try {
        icon = capability->get_icon();
    } catch (const std::exception& error) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " Failed to get icon for plugin " << id.plugin_key << ": " << error.what();
    } catch (...) {
        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " Failed to get icon for plugin " << id.plugin_key;
    }
 
    wxBitmap bitmap;
    if (!icon.empty()) {
        try {
            boost::filesystem::path icon_path(icon);
            const std::string extension = icon_path.extension().string();
            if (extension == ".svg" || extension == ".png")
                icon_path.replace_extension();
 
            bitmap = create_scaled_bitmap(icon_path.string(), m_parent, 20);
        } catch (const std::exception& error) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " Failed to load icon for plugin " << id.plugin_key << ": " << error.what();
        } catch (...) {
            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " Failed to load icon for plugin " << id.plugin_key;
        }
    }
 
    // Built the first time its tab is shown, so a language switch never creates the page's browser
    // while the main window is being rebuilt. Never prebuilt: the idle queue cannot drop a page
    // that remove_page() destroys.
    auto* page = new GUI::LazyPage<PluginPage>(m_parent, GUI::into_u8(page_tab_id(id)), -1,
                                               [capability = std::move(capability)](wxWindow* parent) {
                                                   return new PluginPage(parent, capability);
                                               });
 
    m_pages.emplace(id, Page{page, bitmap});
    m_order.push_back(id);
    return true;
}

References create_scaled_bitmap(), get_pages_cap(), Slic3r::GUI::into_u8(), m_order, m_pages, m_parent, and page_tab_id().

Referenced by initialize(), and on_cap_register().

Here is the call graph for this function:

Here is the caller graph for this function:

get_pages_cap()

std::shared_ptr< PagesPluginCapability > Slic3r::PluginPages::get_pages_cap ( const PluginCapabilityId & id, bool is_enabled ) const

private

{
    auto capability = PluginManager::instance().get_plugin_capability(id, /*only_enabled=*/false);
    if (!capability || capability->is_enabled() != is_enabled || capability->type() != PluginCapabilityType::Pages)
        return nullptr;
 
    return std::dynamic_pointer_cast<PagesPluginCapability>(capability);
}

References Slic3r::PluginManager::get_plugin_capability(), Slic3r::PluginManager::instance(), and Slic3r::Pages.

Referenced by create_page().

Here is the call graph for this function:

Here is the caller graph for this function:

initialize()

void Slic3r::PluginPages::initialize

(

Notebook *

parent

)

{
    shutdown();
    m_parent = parent;
    if (m_parent == nullptr)
        return;
 
    m_visible_page_count = GUI::wxGetApp().app_config->get_plugin_pages_visible_count();
 
    for (const auto& capability : PluginManager::instance().get_plugin_capabilities("", PluginCapabilityType::Pages)) {
        if (capability)
            create_page(capability->identity());
    }
    relayout();
}

References create_page(), Slic3r::PluginManager::instance(), m_parent, m_visible_page_count, Slic3r::Pages, relayout(), and shutdown().

Here is the call graph for this function:

on_cap_deregister()

void Slic3r::PluginPages::on_cap_deregister

(

const PluginCapabilityId &

id

)

{
    remove_page(id);
}

References remove_page().

Here is the call graph for this function:

on_cap_register()

void Slic3r::PluginPages::on_cap_register

(

const PluginCapabilityId &

id

)

{
    if (m_parent == nullptr)
        return;
 
    if (create_page(id))
        relayout();
}

References create_page(), m_parent, and relayout().

Referenced by on_plugin_register().

Here is the call graph for this function:

Here is the caller graph for this function:

on_plugin_deregister()

void Slic3r::PluginPages::on_plugin_deregister

(

const std::string &

plugin_key

)

{
    // In tab order, as in shutdown().
    for (const PluginCapabilityId& id : std::vector<PluginCapabilityId>(m_order))
        if (id.plugin_key == plugin_key)
            remove_page(id);
}

References m_order, and remove_page().

Here is the call graph for this function:

on_plugin_register()

void Slic3r::PluginPages::on_plugin_register

(

const std::string &

plugin_key

)

{
    for (const auto& capability : PluginManager::instance().get_plugin_capabilities(plugin_key, PluginCapabilityType::Pages)) {
        if (capability)
            on_cap_register(capability->identity());
    }
}

References Slic3r::PluginManager::instance(), on_cap_register(), and Slic3r::Pages.

Here is the call graph for this function:

operator=()

PluginPages & Slic3r::PluginPages::operator= ( const PluginPages & )

delete

References PluginPages(), and count.

Here is the call graph for this function:

page_tab_id()

wxString Slic3r::PluginPages::page_tab_id ( const PluginCapabilityId & id )

staticprivate

{
    return wxString::FromUTF8("plugin." + id.plugin_key + "." + id.name);
}

Referenced by create_page(), relayout(), select_page(), and show_overflow_menu().

Here is the caller graph for this function:

relayout()

void Slic3r::PluginPages::relayout

(

)

{
    if (m_parent == nullptr)
        return;
 
    m_order.erase(std::remove_if(m_order.begin(), m_order.end(),
        [this](const PluginCapabilityId& id) {
            const bool orphaned = m_pages.find(id) == m_pages.end();
            if (orphaned)
                BOOST_LOG_TRIVIAL(error) << "PluginPages::relayout: '" << id.name << "' was in m_order but not m_pages, dropping";
            return orphaned;
        }),
        m_order.end());
 
    const int visible_slots = std::max(1, m_visible_page_count);
    const bool need_overflow = static_cast<int>(m_order.size()) > visible_slots;
 
    // Every visible slot is a normal, individual tab hosting its own page. When there's
    // overflow, the last slot's page is swappable via m_overflow_button/show_overflow_menu()
    // rather than being a fixed page — m_swapped_in_id tracks which one currently sits there.
    std::vector<PluginCapabilityId> tab_ids;
    if (!need_overflow) {
        tab_ids = m_order;
        m_swapped_in_id.reset();
    } else {
        const auto overflow_begin = m_order.begin() + (visible_slots - 1);
        tab_ids.assign(m_order.begin(), overflow_begin);
 
        if (!m_swapped_in_id || std::find(overflow_begin, m_order.end(), *m_swapped_in_id) == m_order.end())
            m_swapped_in_id = *overflow_begin;
        tab_ids.push_back(*m_swapped_in_id);
    }
 
    // MainFrame::show_device() relayouts on every printer change and most of those change
    // nothing, so only touch the notebook when the trailing slots don't already spell out
    // tab_ids — a rebuild destroys and recreates every tab button and rasterizes every icon.
    const size_t page_count = m_parent->GetPageCount();
    bool up_to_date = page_count >= tab_ids.size();
    for (size_t i = 0; up_to_date && i < tab_ids.size(); ++i)
        up_to_date = m_parent->GetPageName(page_count - tab_ids.size() + i) == page_tab_id(tab_ids[i]);
    for (const auto& [id, entry] : m_pages) {
        if (!up_to_date)
            break;
        const bool wanted = std::find(tab_ids.begin(), tab_ids.end(), id) != tab_ids.end();
        up_to_date = entry.page->in_book() == wanted;
    }
 
    if (!up_to_date) {
        const wxString id_to_reselect = m_parent->GetSelectedPageName();
 
        // In tab order, as in shutdown().
        for (const auto& id : m_order) {
            const int idx = m_parent->FindPage(m_pages.at(id).page);
            if (idx != wxNOT_FOUND)
                m_parent->RemovePage(idx);
        }
 
        for (const auto& id : tab_ids) {
            const Page& entry = m_pages.at(id);
            m_parent->InsertPage(m_parent->GetPageCount(), page_tab_id(id), entry.page, wxString::FromUTF8(id.name), "",
                                 false, entry.icon);
        }
 
        if (!id_to_reselect.empty())
            m_parent->SelectPageByName(id_to_reselect);
    }
 
    const bool overflow_changed = need_overflow != (m_overflow_button != nullptr);
    if (need_overflow) {
        if (m_overflow_button == nullptr) {
            auto* btn = new Button(m_parent->GetBtnsListCtrl(), wxString(L"\u25BE"), wxString(), wxNO_BORDER);
            btn->SetCornerRadius(0);
            const int em = em_unit(m_parent);
            btn->SetMinSize({40 * em / 10, 36 * em / 10});
            btn->Bind(wxEVT_BUTTON, [this](wxCommandEvent&) { show_overflow_menu(); });
            GUI::wxGetApp().UpdateDarkUI(btn);
            m_overflow_button = btn;
        }
        m_parent->SetOverflowButton(m_overflow_button);
    } else if (m_overflow_button != nullptr) {
        m_parent->SetOverflowButton(nullptr);
        m_overflow_button->Destroy();
        m_overflow_button = nullptr;
    }
 
    // The tab strip changed width; compact the labels again so the side tools stay visible.
    if ((!up_to_date || overflow_changed) && !GUI::wxGetApp().is_closing())
        if (GUI::MainFrame* mainframe = GUI::wxGetApp().mainframe)
            mainframe->fit_tab_labels();
}

References em_unit(), Slic3r::PluginPages::Page::icon, L, m_order, m_overflow_button, m_pages, m_parent, m_swapped_in_id, m_visible_page_count, Slic3r::PluginPages::Page::page, page_tab_id(), and show_overflow_menu().

Referenced by initialize(), on_cap_register(), remove_page(), select_page(), set_visible_page_count(), and show_overflow_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_page()

void Slic3r::PluginPages::remove_page ( const PluginCapabilityId & id )

private

{
    auto it = m_pages.find(id);
    if (it == m_pages.end())
        return;
 
    GUI::LazyPage<PluginPage>* page = it->second.page;
    // Only a built page has installed a message sender on the capability.
    if (PluginPage* built = page->get())
        built->detach_capability();
 
    m_pages.erase(it);
    m_order.erase(std::remove(m_order.begin(), m_order.end(), id), m_order.end());
 
    const int idx = m_parent != nullptr ? m_parent->FindPage(page) : wxNOT_FOUND;
    if (idx != wxNOT_FOUND)
        m_parent->RemovePage(idx);
 
    relayout();
    page->Destroy();
}

References Slic3r::GUI::Lazy< T >::get(), m_order, m_pages, m_parent, and relayout().

Referenced by on_cap_deregister(), on_plugin_deregister(), and shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

select_page()

void Slic3r::PluginPages::select_page

(

const PluginCapabilityId &

id

)

{
    if (m_parent == nullptr || m_pages.find(id) == m_pages.end())
        return;
 
    // Swap the page into the visible slot first when it lives behind the overflow menu.
    m_swapped_in_id = id;
    relayout();
    m_parent->SelectPageByName(page_tab_id(id));
}

References m_pages, m_parent, m_swapped_in_id, page_tab_id(), and relayout().

Referenced by Slic3r::GUI::anonymous_namespace{ActionRegistry.cpp}::PluginPageAction::run().

Here is the call graph for this function:

Here is the caller graph for this function:

set_visible_page_count()

void Slic3r::PluginPages::set_visible_page_count

(

int

count

)

{
    const int clamped = std::clamp(count, PLUGIN_PAGES_VISIBLE_COUNT_MIN, PLUGIN_PAGES_VISIBLE_COUNT_MAX);
    if (clamped == m_visible_page_count)
        return;
 
    m_visible_page_count = clamped;
    relayout();
}

References count, m_visible_page_count, PLUGIN_PAGES_VISIBLE_COUNT_MAX, PLUGIN_PAGES_VISIBLE_COUNT_MIN, and relayout().

Here is the call graph for this function:

show_overflow_menu()

void Slic3r::PluginPages::show_overflow_menu ( )

private

{
    const int visible_slots = std::max(1, m_visible_page_count);
    if (m_overflow_button == nullptr || static_cast<int>(m_order.size()) <= visible_slots)
        return;
 
    const std::vector<PluginCapabilityId> overflow_ids(m_order.begin() + (visible_slots - 1), m_order.end());
 
    wxMenu menu;
    for (size_t i = 0; i < overflow_ids.size(); ++i)
        menu.AppendRadioItem(static_cast<int>(wxID_HIGHEST + 1 + i), wxString::FromUTF8(overflow_ids[i].name));
    if (m_swapped_in_id) {
        const auto it = std::find(overflow_ids.begin(), overflow_ids.end(), *m_swapped_in_id);
        if (it != overflow_ids.end())
            menu.Check(static_cast<int>(wxID_HIGHEST + 1 + (it - overflow_ids.begin())), true);
    }
 
    menu.Bind(wxEVT_MENU, [this, overflow_ids](wxCommandEvent& evt) {
        const size_t index = static_cast<size_t>(evt.GetId() - (wxID_HIGHEST + 1));
        if (index >= overflow_ids.size())
            return;
        m_swapped_in_id = overflow_ids[index];
        relayout();
        m_parent->SelectPageByName(page_tab_id(*m_swapped_in_id));
    });
    m_overflow_button->PopupMenu(&menu);
}

References m_order, m_overflow_button, m_parent, m_swapped_in_id, m_visible_page_count, page_tab_id(), and relayout().

Referenced by relayout().

Here is the call graph for this function:

Here is the caller graph for this function:

shutdown()

void Slic3r::PluginPages::shutdown

(

)

{
    // Removing the selected tab selects the tab to its left. In tab order that is a built-in tab,
    // never an unbuilt plugin page that is removed next and would be built only to be destroyed.
    for (const PluginCapabilityId& id : std::vector<PluginCapabilityId>(m_order))
        remove_page(id);
    m_parent = nullptr;
}

References m_order, m_parent, and remove_page().

Referenced by ~PluginPages(), and initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_order

std::vector<PluginCapabilityId> Slic3r::PluginPages::m_order

private

Referenced by create_page(), on_plugin_deregister(), relayout(), remove_page(), show_overflow_menu(), and shutdown().

m_overflow_button

wxWindow* Slic3r::PluginPages::m_overflow_button {nullptr}

private

{nullptr};

Referenced by relayout(), and show_overflow_menu().

m_pages

std::map<PluginCapabilityId, Page> Slic3r::PluginPages::m_pages

private

Referenced by create_page(), relayout(), remove_page(), and select_page().

m_parent

Notebook* Slic3r::PluginPages::m_parent {nullptr}

private

{nullptr};

Referenced by create_page(), initialize(), on_cap_register(), relayout(), remove_page(), select_page(), show_overflow_menu(), and shutdown().

m_swapped_in_id

std::optional<PluginCapabilityId> Slic3r::PluginPages::m_swapped_in_id

private

Referenced by relayout(), select_page(), and show_overflow_menu().

m_visible_page_count

int Slic3r::PluginPages::m_visible_page_count {0}

private

{0};

Referenced by initialize(), relayout(), set_visible_page_count(), and show_overflow_menu().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/plugin/host/PluginPages.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/plugin/host/PluginPages.cpp