Slic3r::GUI::ActionRegistry Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/ActionRegistry.hpp>

Collaboration diagram for Slic3r::GUI::ActionRegistry:

Public Member Functions
	~ActionRegistry ()
void	init ()
void	relocalize_builtins ()
void	upsert (std::unique_ptr< AppAction > action)
void	remove (const std::string &id)
const AppAction *	by_id (const std::string &id) const
AppActionRunResult	run (const std::string &id, const std::string &param={})
bool	set_favourite (const std::string &id, bool on)
void	reorder_favourites (const std::vector< std::string > &ids)
std::vector< std::string >	favourite_ids () const
bool	should_ask (const std::string &id) const
void	suppress_ask (const std::string &id)
bool	tooltip_expanded () const
void	set_tooltip_expanded (bool expanded)
nlohmann::json	snapshot ()
nlohmann::json	tab_options () const

Static Public Attributes
static constexpr size_t	kFavLimit = 10

Private Member Functions
void	seed_state (AppAction &a) const
AppAction *	find (const std::string &id)
void	load_persisted (nlohmann::json &stats, std::vector< std::string > &favs) const
void	materialize_setting_actions ()
void	materialize_plate_actions ()
void	materialize_recent_project_actions ()
void	refresh_source (const std::string &plugin_key, ActionChange change)
void	refresh_capability (const std::string &plugin_key, const std::string &capability, ActionChange change)
void	refresh_page_capability (const std::string &plugin_key, const std::string &capability, ActionChange change)

Private Attributes
bool	m_started = false
std::unordered_map< std::string, std::shared_ptr< AppAction > >	m_actions

Detailed Description

Constructor & Destructor Documentation

~ActionRegistry()

Slic3r::GUI::ActionRegistry::~ActionRegistry ( )

default

Member Function Documentation

by_id()

const AppAction * Slic3r::GUI::ActionRegistry::by_id

(

const std::string &

id

)

const

{
    assert(wxThread::IsMain());
    auto it = m_actions.find(id);
    return it == m_actions.end() ? nullptr : it->second.get();
}

References m_actions.

Referenced by find(), and Slic3r::GUI::SpeedDialWebDialog::run_action().

Here is the caller graph for this function:

favourite_ids()

std::vector< std::string > Slic3r::GUI::ActionRegistry::favourite_ids

(

)

const

{
    assert(wxThread::IsMain());
    // Enforce the cap + dedupe on read so the persisted order can never grow past kFavLimit, even from an older config.
    return cap_favourites(read_string_array("favourite_actions"), kFavLimit);
}

References Slic3r::GUI::cap_favourites(), and kFavLimit.

Referenced by load_persisted(), seed_state(), set_favourite(), and snapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

find()

AppAction * Slic3r::GUI::ActionRegistry::find ( const std::string & id )

private

{ return const_cast<AppAction*>(by_id(id)); }

References by_id().

Referenced by run(), and set_favourite().

Here is the call graph for this function:

Here is the caller graph for this function:

init()

void Slic3r::GUI::ActionRegistry::init

(

)

{
    assert(wxThread::IsMain());
    assert(!m_started);
    m_started = true;
 
    PluginManager& manager = PluginManager::instance();
 
    auto on_source = [this](const std::string& plugin_key, ActionChange change) {
        if (!wxTheApp || wxGetApp().is_closing())
            return;
        wxGetApp().CallAfter([this, plugin_key, change] {
            if (!wxGetApp().is_closing())
                this->refresh_source(plugin_key, change);
        });
    };
    auto on_capability = [this](const PluginCapabilityId& capability, ActionChange change) {
        if (capability.type != PluginCapabilityType::Script && capability.type != PluginCapabilityType::Pages)
            return;
        if (!wxTheApp || wxGetApp().is_closing())
            return;
        const PluginCapabilityType type = capability.type;
        const std::string plugin_key    = capability.plugin_key;
        const std::string name          = capability.name;
        wxGetApp().CallAfter([this, type, plugin_key, name, change] {
            if (wxGetApp().is_closing())
                return;
            if (type == PluginCapabilityType::Script)
                this->refresh_capability(plugin_key, name, change);
            else
                this->refresh_page_capability(plugin_key, name, change);
        });
    };
 
    // Subscribe before enumerating so a concurrent load cannot land between the initial
    // snapshot and callback registration. Duplicate notifications are safe: upsert is by
    // id and the m_actions scan in refresh_source is idempotent.
    manager.subscribe_on_load_callback([on_source](const std::string& key) { on_source(key, ActionChange::Added); });
    manager.subscribe_on_unload_callback([on_source](const std::string& key) { on_source(key, ActionChange::Removed); });
    manager.subscribe_on_capability_load_callback(
        [on_capability](const PluginCapabilityId& capability) { on_capability(capability, ActionChange::Added); });
    manager.subscribe_on_capability_unload_callback(
        [on_capability](const PluginCapabilityId& capability) { on_capability(capability, ActionChange::Removed); });
 
    // enumerate current script capabilities
    std::unordered_map<std::string, std::string> source_names;
    for (const PluginDescriptor& desc : manager.get_plugin_descriptors())
        if (!desc.name.empty())
            source_names.emplace(desc.plugin_key, desc.name);
 
    for (const auto& capability : manager.get_plugin_capabilities("", PluginCapabilityType::Script)) {
        if (!capability)
            continue;
        const std::string& key         = capability->audit_plugin_key();
        auto it                        = source_names.find(key);
        const std::string& source_name = it == source_names.end() ? key : it->second;
        if (auto action = make_action(key, capability->name(), source_name))
            upsert(std::move(action));
    }
 
    for (const auto& capability : manager.get_plugin_capabilities("", PluginCapabilityType::Pages)) {
        if (!capability)
            continue;
        const std::string& key         = capability->audit_plugin_key();
        auto it                        = source_names.find(key);
        const std::string& source_name = it == source_names.end() ? key : it->second;
        if (auto action = make_page_action(key, capability->name(), source_name))
            upsert(std::move(action));
    }
 
    // Built-in palette commands (Save/Load, Preferences, Mode switch, Slice/Preview, Go to layer).
    // Register after plugins so the plugin ids win on any (unlikely) id collision - ids are distinct
    // by prefix, so this is order-independent. The catalog (and its thin AppAction adapter) lives in
    // NativeCommands; the registry only stores and dispatches the result.
    for (const NativeCommand& c : NativeCommands::catalog())
        upsert(NativeCommands::make_action(c));
}

References Slic3r::GUI::Added, Slic3r::GUI::NativeCommands::catalog(), Slic3r::PluginManager::get_plugin_capabilities(), Slic3r::PluginManager::get_plugin_descriptors(), Slic3r::PluginManager::instance(), m_started, Slic3r::GUI::NativeCommands::make_action(), Slic3r::PluginCapabilityId::name, Slic3r::Pages, Slic3r::PluginCapabilityId::plugin_key, refresh_capability(), refresh_page_capability(), refresh_source(), Slic3r::GUI::Removed, Slic3r::Script, Slic3r::PluginManager::subscribe_on_capability_load_callback(), Slic3r::PluginManager::subscribe_on_capability_unload_callback(), Slic3r::PluginManager::subscribe_on_load_callback(), Slic3r::PluginManager::subscribe_on_unload_callback(), Slic3r::PluginCapabilityId::type, and upsert().

Here is the call graph for this function:

load_persisted()

void Slic3r::GUI::ActionRegistry::load_persisted ( nlohmann::json & stats, std::vector< std::string > & favs ) const

private

{
    stats = read_section("stats", nlohmann::json::object());
    if (!stats.is_object())
        stats = nlohmann::json::object();
    favs = favourite_ids();
}

References favourite_ids().

Referenced by materialize_plate_actions(), materialize_recent_project_actions(), and materialize_setting_actions().

Here is the call graph for this function:

Here is the caller graph for this function:

materialize_plate_actions()

void Slic3r::GUI::ActionRegistry::materialize_plate_actions ( )

private

{
    assert(wxThread::IsMain());
 
    // Plates are a filament (FFF) feature: SLA has a single plate and no plate UI, and gcode-only
    // mode has no editable project - so no "Go to Plate N" actions are offered there.
    Plater* plater = wxTheApp ? wxGetApp().plater() : nullptr;
    if (!plater || plater->printer_technology() != ptFFF || plater->only_gcode_mode()) {
        // Drop any stale plate actions (e.g. the printer technology switched to SLA).
        drop_stale(m_actions, kPlateGotoPrefix, {});
        return;
    }
 
    // Persisted per-action state, read ONCE (mirrors materialize_setting_actions) so a relisted
    // "Go to Plate N" keeps its recency/favourite when the plate is renamed - the id is index-keyed.
    nlohmann::json           stats;
    std::vector<std::string> favs;
    load_persisted(stats, favs);
 
    const std::vector<PartPlate*>& list = plater->get_partplate_list().get_plate_list();
    std::unordered_set<std::string> seen;
    for (size_t i = 0; i < list.size(); ++i) {
        PartPlate* plate = list[i];
        if (!plate)
            continue;
        const std::string id = PlateAction::id_for(int(i));
        seen.insert(id);
 
        // "Go to Plate N" + " (name)" when the plate is named, matching the object-list label.
        const char* go_to_plate = L("Go to Plate");
        std::string suffix      = " " + std::to_string(i + 1);
        const std::string name  = plate->get_plate_name();
        if (!name.empty())
            suffix += " (" + name + ")";
 
        auto action      = std::make_unique<PlateAction>(int(i), I18N::translate_utf8(go_to_plate) + suffix, kOrcaSourceName);
        action->title_en = go_to_plate + suffix;
        seed_from(stats, favs, id, *action);
        auto const action_id  = action->id();
        auto const app_action = std::shared_ptr<AppAction>(std::move(action));
        m_actions.insert_or_assign(action_id, app_action);
    }
 
    // Drop plate actions whose index no longer exists (a plate was deleted / moved to the front).
    drop_stale(m_actions, kPlateGotoPrefix, seen);
}

References Slic3r::GUI::PartPlate::get_plate_name(), Slic3r::GUI::kOrcaSourceName, L, load_persisted(), m_actions, Slic3r::GUI::plater(), Slic3r::ptFFF, and Slic3r::GUI::I18N::translate_utf8().

Referenced by snapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

materialize_recent_project_actions()

void Slic3r::GUI::ActionRegistry::materialize_recent_project_actions ( )

private

{
    assert(wxThread::IsMain());
 
    // Persisted per-action state, read ONCE (mirrors materialize_plate_actions) so a relisted recent
    // project keeps its recency/favourite when the recents list reorders - the id is path-keyed.
    nlohmann::json           stats;
    std::vector<std::string> favs;
    load_persisted(stats, favs);
 
    // app_config stores recents oldest-first; the palette shows newest-first.
    std::vector<std::string> recents = wxGetApp().app_config->get_recent_projects();
    std::reverse(recents.begin(), recents.end());
 
    std::unordered_set<std::string> seen;
    for (const std::string& path : recents) {
        // Skip projects whose file is gone; the stale id is dropped below.
        boost::system::error_code ec;
        if (path.empty() || !boost::filesystem::exists(boost::filesystem::path(path), ec))
            continue;
 
        const std::string id = RecentProjectAction::id_for(path);
        seen.insert(id);
 
        // Title = file basename; source/eyebrow = the full path so search can match either.
        boost::filesystem::path p(path);
        std::string title = p.filename().string();
        if (title.empty())
            title = path;
 
        auto action = std::make_unique<RecentProjectAction>(path, std::move(title), path);
        seed_from(stats, favs, id, *action);
        auto const action_id  = action->id();
        auto const app_action = std::shared_ptr<AppAction>(std::move(action));
        m_actions.insert_or_assign(action_id, app_action);
    }
 
    // Drop recent-project actions whose file no longer exists / was removed from the recents list.
    drop_stale(m_actions, kRecentProjectPrefix, seen);
}

References load_persisted(), and m_actions.

Referenced by snapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

materialize_setting_actions()

void Slic3r::GUI::ActionRegistry::materialize_setting_actions ( )

private

{
    assert(wxThread::IsMain());
 
    // Reuse the Sidebar's live settings index: it's the only catalog whose group/category map is
    // populated (Tab::add_key feeds it at build time), and it already mirrors the current
    // configs/printer-technology. Use the all-modes view so the Speed Dial lists every setting,
    // including those above the user's current mode, and can prompt to switch before jumping.
    const std::vector<Search::Option>& options = wxGetApp().sidebar().settings_index().all_options();
 
    // Load the persisted per-action state ONCE (not per-option) so a re-materialised setting keeps
    // its recency/favourite; mirroring seed_state but amortised over the whole option set.
    nlohmann::json           stats;
    std::vector<std::string> favs;
    load_persisted(stats, favs);
 
    std::unordered_set<std::string> seen;
    for (const Search::Option& opt : options) {
        // The row's live state drives both the hidden filter and the title (labels can change at
        // runtime, e.g. brim_width -> "Brim ear radius"). Hidden rows are skipped, not marked seen.
        Tab* tab = wxGetApp().get_tab(opt.type);
        Tab::SettingRowState row;
        if (tab)
            row = tab->setting_row_state(opt.opt_key());
        if (!row.visible)
            continue;
 
        const std::string id = SettingAction::id_for(opt.opt_key(), opt.type);
        seen.insert(id);
 
        // The localized text the page shows, and its English search aliases from the untranslated row
        // label, def name and breadcrumb.
        const char* type_context = setting_type_context(opt.type);
        SettingText local   = setting_text(opt.label_local.empty() ? opt.label : opt.label_local, opt.display_label, row.label, row.multi,
                                           I18N::translate_utf8(type_context), opt.category_local, opt.group_local);
        SettingText english = setting_text(opt.label, opt.display_label_en, row.label_en, row.multi, type_context,
                                           Tab::translate_category(opt.category, opt.type, false).ToStdWstring(), opt.group);
 
        // group stays empty so the source path is the single display/search breadcrumb rather than
        // being duplicated.
        auto action = std::make_unique<SettingAction>(opt.opt_key(), opt.type, local.title, std::string(), opt.category, local.source,
                                                      opt.mode);
        action->full_label    = std::move(local.full_label);
        action->title_en      = std::move(english.title);
        action->full_label_en = std::move(english.full_label);
        action->source_en     = std::move(english.source);
 
        // Tile pictogram = the icon of the setting's own group header (e.g. Advanced -> param_advanced),
        // the one shown next to it in the page. Fall back to the page/category icon for groups
        // without one. Keys are the English titles the GUI registers.
        action->icon = opt.group_icon;
        if (action->icon.empty() && !opt.category.empty() && tab) {
            const auto& icons = tab->get_category_icon_map();
            auto        it    = icons.find(wxString(opt.category));
            if (it != icons.end())
                action->icon = it->second;
        }
 
        // Footer description + wiki affordance; only settings whose row declared a wiki path have one.
        action->tooltip = opt.tooltip;
        if (!opt.wiki_path.empty())
            action->help_url = into_u8(OptionsGroup::get_url(opt.wiki_path));
 
        seed_from(stats, favs, id, *action);
        auto const action_id  = action->id();
        auto const app_action = std::shared_ptr<AppAction>(std::move(action));
        m_actions.insert_or_assign(action_id, app_action);
    }
 
    // Drop SettingActions whose option no longer exists in the current configs (e.g. the printer
    // technology / UI mode changed). Non-setting actions are untouched.
    drop_stale(m_actions, kSettingPrefix, seen);
}

References Slic3r::GUI::Tab::get_category_icon_map(), Slic3r::GUI::OptionsGroup::get_url(), Slic3r::GUI::into_u8(), Slic3r::GUI::Tab::SettingRowState::label, Slic3r::GUI::Tab::SettingRowState::label_en, load_persisted(), m_actions, Slic3r::GUI::Tab::SettingRowState::multi, Slic3r::GUI::Tab::setting_row_state(), Slic3r::GUI::Tab::translate_category(), Slic3r::GUI::I18N::translate_utf8(), and Slic3r::GUI::Tab::SettingRowState::visible.

Referenced by snapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

refresh_capability()

void Slic3r::GUI::ActionRegistry::refresh_capability ( const std::string & plugin_key, const std::string & capability, ActionChange change )

private

{
    assert(wxThread::IsMain());
 
    const std::string id = PluginScriptAction::id_for(plugin_key, capability);
    if (change == ActionChange::Removed) {
        remove(id);
        return;
    }
 
    PluginManager& manager = PluginManager::instance();
    if (auto action = make_action(plugin_key, capability, find_loaded_source_name(manager, plugin_key)))
        upsert(std::move(action));
    else
        remove(id);
}

References Slic3r::PluginManager::instance(), remove(), Slic3r::GUI::Removed, and upsert().

Referenced by init().

Here is the call graph for this function:

Here is the caller graph for this function:

refresh_page_capability()

void Slic3r::GUI::ActionRegistry::refresh_page_capability ( const std::string & plugin_key, const std::string & capability, ActionChange change )

private

{
    assert(wxThread::IsMain());
 
    const std::string id = PluginPageAction::id_for(plugin_key, capability);
    if (change == ActionChange::Removed) {
        remove(id);
        return;
    }
 
    PluginManager& manager = PluginManager::instance();
    if (auto action = make_page_action(plugin_key, capability, find_loaded_source_name(manager, plugin_key)))
        upsert(std::move(action));
    else
        remove(id);
}

References Slic3r::PluginManager::instance(), remove(), Slic3r::GUI::Removed, and upsert().

Referenced by init().

Here is the call graph for this function:

Here is the caller graph for this function:

refresh_source()

void Slic3r::GUI::ActionRegistry::refresh_source ( const std::string & plugin_key, ActionChange change )

private

{
    assert(wxThread::IsMain());
 
    // Remove this source's current actions. Collect first - erasing from m_actions while
    // iterating invalidates the iterator. why: m_actions (not the loader) is the source of
    // truth, so this is correct even after the plugin has already unloaded.
    std::vector<std::string> stale;
    for (const auto& [id, action] : m_actions)
        if (action->source_key() == plugin_key)
            stale.push_back(id);
    for (const std::string& id : stale)
        remove(id);
 
    if (change == ActionChange::Removed)
        return;
 
    PluginManager& manager        = PluginManager::instance();
    const std::string source_name = find_loaded_source_name(manager, plugin_key);
    for (const auto& capability : manager.get_plugin_capabilities(plugin_key, PluginCapabilityType::Script)) {
        if (!capability)
            continue;
        if (auto action = make_action(plugin_key, capability->name(), source_name))
            upsert(std::move(action));
    }
    for (const auto& capability : manager.get_plugin_capabilities(plugin_key, PluginCapabilityType::Pages)) {
        if (!capability)
            continue;
        if (auto action = make_page_action(plugin_key, capability->name(), source_name))
            upsert(std::move(action));
    }
}

References Slic3r::PluginManager::get_plugin_capabilities(), Slic3r::PluginManager::instance(), m_actions, Slic3r::Pages, remove(), Slic3r::GUI::Removed, Slic3r::Script, and upsert().

Referenced by init().

Here is the call graph for this function:

Here is the caller graph for this function:

relocalize_builtins()

void Slic3r::GUI::ActionRegistry::relocalize_builtins

(

)

{
    assert(wxThread::IsMain());
    if (!m_started)
        return;
 
    // Drop only the built-in commands; plugins and the dynamically materialised families are
    // either unlocalized or rebuilt per snapshot. remove() only erases the map entry, and upsert()
    // re-seeds favourites/stats from config, so key-based ids keep their pinned state. make_action()
    // translates in the new locale.
    std::vector<std::string> stale;
    for (const auto& [id, action] : m_actions)
        if (action->source_key() == kOrcaSourceKey && action->kind == AppActionKind::Command)
            stale.push_back(id);
    for (const std::string& id : stale)
        remove(id);
 
    for (const NativeCommand& c : NativeCommands::catalog())
        upsert(NativeCommands::make_action(c));
}

References Slic3r::GUI::NativeCommands::catalog(), Slic3r::GUI::Command, Slic3r::GUI::kOrcaSourceKey, m_actions, m_started, Slic3r::GUI::NativeCommands::make_action(), remove(), and upsert().

Here is the call graph for this function:

remove()

void Slic3r::GUI::ActionRegistry::remove

(

const std::string &

id

)

{
    assert(wxThread::IsMain());
    m_actions.erase(id);
}

References m_actions.

Referenced by refresh_capability(), refresh_page_capability(), refresh_source(), and relocalize_builtins().

Here is the caller graph for this function:

reorder_favourites()

void Slic3r::GUI::ActionRegistry::reorder_favourites

(

const std::vector< std::string > &

ids

)

{
    assert(wxThread::IsMain());
    auto cur = read_string_array("favourite_actions");
    std::vector<std::string> next;
    // keep the requested order, but only ids that are actually favourites (guard a bad payload)
    for (const auto& id : ids)
        if (std::find(cur.begin(), cur.end(), id) != cur.end() && std::find(next.begin(), next.end(), id) == next.end())
            next.push_back(id);
    // why: don't drop favourites the page omitted (e.g. pins with no live action hidden from the bar)
    for (const auto& id : cur)
        if (std::find(next.begin(), next.end(), id) == next.end())
            next.push_back(id);
    // never write the bar back larger than the quick-launch slots
    next = cap_favourites(next, kFavLimit);
    write_section("favourite_actions", nlohmann::json(next));
}

References Slic3r::GUI::cap_favourites(), and kFavLimit.

Here is the call graph for this function:

run()

AppActionRunResult Slic3r::GUI::ActionRegistry::run	(	const std::string &	id,
		const std::string &	param = {} )

{
    assert(wxThread::IsMain());
    auto it = m_actions.find(id);
    if (it == m_actions.end())
        return {}; // default Info, empty message
    // why: hold a shared_ptr keep-alive, never a bare map entry. A runner may pump a
    // nested event loop; a queued source refresh can erase the entry while the
    // keep-alive preserves the action until run returns.
    std::shared_ptr<AppAction> keep = it->second;
    AppActionRunResult o            = keep->run(param);
    if (o.level == AppActionRunResult::Level::Busy)
        return o;
 
    // Bump stats (write-through). Re-read to avoid clobbering a concurrent field.
    nlohmann::json stats = read_section("stats", nlohmann::json::object());
    if (!stats.is_object()) // corrupt (valid-JSON, non-object) value degrades to empty
        stats = nlohmann::json::object();
    nlohmann::json& e = stats[id];
    if (!e.is_object())
        e = nlohmann::json::object();
    e["count"] = e.value("count", 0) + 1;
    e["last"]  = (long long) std::time(nullptr);
    write_section("stats", stats);
    if (AppAction* live = find(id)) {
        live->count = e["count"];
        live->last  = e["last"];
    }
    return o;
}

References Slic3r::GUI::AppActionRunResult::Busy, find(), Slic3r::GUI::AppActionRunResult::level, and m_actions.

Here is the call graph for this function:

seed_state()

void Slic3r::GUI::ActionRegistry::seed_state ( AppAction & a ) const

private

{
    // Favourites carry the quick-launch order, so the persisted list is the source of truth
    // (not re-derived from the frecency sort). Cap it so stale configs can't exceed kFavLimit.
    auto favs   = favourite_ids();
    a.favourite = std::find(favs.begin(), favs.end(), a.id()) != favs.end();
 
    nlohmann::json stats = read_section("stats", nlohmann::json::object());
    auto it              = stats.find(a.id());
    if (it != stats.end() && it->is_object()) {
        a.count = it->value("count", 0);
        a.last  = it->value("last", 0LL);
    } else {
        a.count = 0;
        a.last  = 0;
    }
}

References Slic3r::GUI::AppAction::count, Slic3r::GUI::AppAction::favourite, favourite_ids(), Slic3r::GUI::AppAction::id(), and Slic3r::GUI::AppAction::last.

Referenced by upsert().

Here is the call graph for this function:

Here is the caller graph for this function:

set_favourite()

bool Slic3r::GUI::ActionRegistry::set_favourite	(	const std::string &	id,
		bool	on )

{
    assert(wxThread::IsMain());
    // Start from the capped, deduped list so a persisted config can never be written back larger.
    auto favs = favourite_ids();
    auto it   = std::find(favs.begin(), favs.end(), id);
    if (on && it == favs.end()) {
        if (favs.size() >= kFavLimit)
            return false; // bar is full - the caller surfaces a hint
        favs.push_back(id);
    }
    if (!on && it != favs.end())
        favs.erase(it);
    write_section("favourite_actions", nlohmann::json(favs));
    if (AppAction* live = find(id))
        live->favourite = on;
    return true;
}

References favourite_ids(), find(), and kFavLimit.

Here is the call graph for this function:

set_tooltip_expanded()

void Slic3r::GUI::ActionRegistry::set_tooltip_expanded

(

bool

expanded

)

{
    assert(wxThread::IsMain());
    write_section("tooltip_expanded", nlohmann::json(expanded));
}

should_ask()

bool Slic3r::GUI::ActionRegistry::should_ask

(

const std::string &

id

)

const

{
    assert(wxThread::IsMain());
    auto arr = read_string_array("ask_suppressed");
    return std::find(arr.begin(), arr.end(), id) == arr.end();
}

Referenced by Slic3r::GUI::SpeedDialWebDialog::run_action().

Here is the caller graph for this function:

snapshot()

nlohmann::json Slic3r::GUI::ActionRegistry::snapshot

(

)

{
    assert(wxThread::IsMain());
    // Settings and plates are first-class actions; make sure the current visible option set and the
    // live plate list are materialised before we serialise the pool (tabs_list is built by the time
    // the palette opens).
    materialize_setting_actions();
    materialize_plate_actions();
    materialize_recent_project_actions();
 
    std::vector<const AppAction*> sorted;
    sorted.reserve(m_actions.size());
    for (const auto& entry : m_actions)
        sorted.push_back(entry.second.get());
 
    const long long now = (long long) std::time(nullptr);
    std::sort(sorted.begin(), sorted.end(), [&](const AppAction* a, const AppAction* b) {
        double sa = frecency_score(a->count, a->last, now);
        double sb = frecency_score(b->count, b->last, now);
        if (sa != sb)
            return sa > sb;
        if (a->title() != b->title())
            return a->title() < b->title();
        if (a->source_name() != b->source_name())
            return a->source_name() < b->source_name();
        return a->id() < b->id();
    });
 
    nlohmann::json actions = nlohmann::json::array();
    for (const AppAction* a : sorted)
        actions.push_back(action_json(*a));
 
    // why: favourites is the ORDERED pin list - it must come from favourite_actions
    // as stored, not be re-derived from the frecency-sorted actions (that would
    // reorder the favourites bar). Drop pins with no live action (an option hidden by the
    // current mode, an unloaded plugin, a gone plate/project) and persist the pruned list, so
    // invisible pins can't silently fill the quick-launch cap. Order is preserved.
    std::vector<std::string> favs = favourite_ids();
    std::vector<std::string> live_favs;
    live_favs.reserve(favs.size());
    for (const auto& id : favs)
        if (m_actions.count(id))
            live_favs.push_back(id);
    if (live_favs.size() != favs.size())
        write_section("favourite_actions", nlohmann::json(live_favs));
    nlohmann::json favourites(live_favs);
 
    // Recent = the last-N launched actions by recency (only actions with a run history). N is a
    // user preference; 0 hides recents without affecting the frecency order below.
    const size_t recent_limit = size_t(wxGetApp().app_config->get_speed_dial_recent_count());
    std::vector<const AppAction*> recent;
    for (const auto& entry : m_actions)
        if (entry.second->last > 0)
            recent.push_back(entry.second.get());
    std::sort(recent.begin(), recent.end(), [](const AppAction* a, const AppAction* b) {
        if (a->last != b->last)
            return a->last > b->last;
        return a->id() < b->id();
    });
    if (recent.size() > recent_limit)
        recent.resize(recent_limit);
    nlohmann::json recent_json = nlohmann::json::array();
    for (const AppAction* a : recent)
        recent_json.push_back(action_json(*a));
 
    return {{"actions", std::move(actions)},
            {"favourites", std::move(favourites)},
            {"recent", std::move(recent_json)},
            {"user_mode", mode_key(wxGetApp().get_mode())},
            {"tooltip_expanded", tooltip_expanded()}};
}

References Slic3r::GUI::action_json(), favourite_ids(), m_actions, materialize_plate_actions(), materialize_recent_project_actions(), materialize_setting_actions(), and tooltip_expanded().

Here is the call graph for this function:

suppress_ask()

void Slic3r::GUI::ActionRegistry::suppress_ask

(

const std::string &

id

)

{
    assert(wxThread::IsMain());
    auto arr = read_string_array("ask_suppressed");
    if (std::find(arr.begin(), arr.end(), id) == arr.end())
        arr.push_back(id);
    write_section("ask_suppressed", nlohmann::json(arr));
}

tab_options()

nlohmann::json Slic3r::GUI::ActionRegistry::tab_options

(

)

const

{
    assert(wxThread::IsMain());
    nlohmann::json out = nlohmann::json::array();
    if (!wxTheApp || wxGetApp().is_closing())
        return out;
    MainFrame* mf = wxGetApp().mainframe;
    if (!mf || !mf->m_tabpanel)
        return out;
    // English labels of the built-in pages whose id is not already their English name, so the tab
    // picker can be searched in English in any UI language.
    static const std::unordered_map<std::string, const char*> english_labels{
        {TAB_ID_MONITOR, L("Device")}, {TAB_ID_MONITOR_WEB, L("Device (Web)")}, {TAB_ID_MULTI_DEVICE, L("Multi-device")}};
 
    Notebook* notebook = mf->m_tabpanel;
    for (size_t i = 0; i < notebook->GetPageCount(); ++i) {
        const wxString id = notebook->GetPageName(i);
        if (id.empty())
            continue;
        const std::string title = notebook->GetPageLabel(i).ToStdString();
        nlohmann::json    tab({{"id", id.ToStdString()}, {"title", title}, {"icon", notebook->GetPageIcon(i)}});
        if (auto it = english_labels.find(id.ToStdString()); it != english_labels.end() && title != it->second)
            tab["title_en"] = it->second;
        out.push_back(std::move(tab));
    }
    return out;
}

References Slic3r::empty(), Notebook::GetPageIcon(), Notebook::GetPageLabel(), Notebook::GetPageName(), L, Slic3r::GUI::MainFrame::m_tabpanel, TAB_ID_MONITOR, TAB_ID_MONITOR_WEB, and TAB_ID_MULTI_DEVICE.

Here is the call graph for this function:

tooltip_expanded()

bool Slic3r::GUI::ActionRegistry::tooltip_expanded

(

)

const

{
    assert(wxThread::IsMain());
    const nlohmann::json j = read_section("tooltip_expanded", nlohmann::json(true));
    return j.is_boolean() ? j.get<bool>() : true;
}

Referenced by snapshot().

Here is the caller graph for this function:

upsert()

void Slic3r::GUI::ActionRegistry::upsert

(

std::unique_ptr< AppAction >

action

)

{
    assert(wxThread::IsMain());
    if (!action)
        return;
 
    seed_state(*action);
    std::string id                    = action->id();
    std::shared_ptr<AppAction> stored = std::move(action);
    m_actions.insert_or_assign(std::move(id), std::move(stored));
}

References m_actions, and seed_state().

Referenced by init(), refresh_capability(), refresh_page_capability(), refresh_source(), and relocalize_builtins().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

kFavLimit

size_t Slic3r::GUI::ActionRegistry::kFavLimit = 10

staticconstexpr

Referenced by favourite_ids(), Slic3r::GUI::SpeedDialWebDialog::handle_web_command(), reorder_favourites(), and set_favourite().

m_actions

std::unordered_map<std::string, std::shared_ptr<AppAction> > Slic3r::GUI::ActionRegistry::m_actions

private

Referenced by by_id(), materialize_plate_actions(), materialize_recent_project_actions(), materialize_setting_actions(), refresh_source(), relocalize_builtins(), remove(), run(), snapshot(), and upsert().

m_started

bool Slic3r::GUI::ActionRegistry::m_started = false

private

Referenced by init(), and relocalize_builtins().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/ActionRegistry.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/ActionRegistry.cpp