Slic3r::PluginConfig Class Reference

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

Collaboration diagram for Slic3r::PluginConfig:

Public Member Functions
void	load ()
bool	save ()
void	save_config (const CapabilityConfigEntry &config)
bool	store_capability_config (const PluginCapabilityId &id, const nlohmann::json &config)
bool	erase_capability_config (const PluginCapabilityId &id)
std::optional< CapabilityConfigEntry >	get_config (const PluginCapabilityId &id) const
bool	has_config (const PluginCapabilityId &id) const
bool	dirty () const

Static Public Member Functions
static const std::string	plugin_config_file ()
static std::string	capability_type_label (PluginCapabilityType type)
static nlohmann::json	capabilities_payload (const std::vector< PluginCapabilityId > &caps)
static nlohmann::json	get_config_response (const PluginCapabilityId &id)
static nlohmann::json	save_config_response (const PluginCapabilityId &id, const nlohmann::json &config)
static nlohmann::json	restore_config_response (const PluginCapabilityId &id)

Private Attributes
std::mutex	m_mutex
CapabilityConfigDocument	m_document
bool	m_dirty = false

Detailed Description

Member Function Documentation

capabilities_payload()

nlohmann::json Slic3r::PluginConfig::capabilities_payload ( const std::vector< PluginCapabilityId > & caps )

static

{
    nlohmann::json payload = nlohmann::json::array();
    for (const PluginCapabilityId& id : caps) {
        // A capability unloaded since the list was built has nothing to configure.
        const auto capability = PluginManager::instance().get_plugin_capability(id, false);
        if (!capability)
            continue;
 
        nlohmann::json entry;
        entry["plugin_key"]    = id.plugin_key;
        entry["name"]          = id.name;
        entry["type"]          = capability_type_label(id.type);
        entry["type_key"]      = plugin_capability_type_to_string(id.type);
        entry["has_config_ui"] = capability->config_ui_available();
        payload.push_back(std::move(entry));
    }
    return payload;
}

References capability_type_label(), Slic3r::PluginManager::get_plugin_capability(), Slic3r::PluginManager::instance(), and Slic3r::plugin_capability_type_to_string().

Referenced by Slic3r::GUI::anonymous_namespace{PluginsDialog.cpp}::build_plugin_payload_item(), and Slic3r::GUI::PluginsConfigDialog::send_capabilities().

Here is the call graph for this function:

Here is the caller graph for this function:

capability_type_label()

std::string Slic3r::PluginConfig::capability_type_label ( PluginCapabilityType type )

static

{
    switch (type) {
    case PluginCapabilityType::PrinterConnection: return _u8L("Printer connection");
    case PluginCapabilityType::Pages: return _u8L("Pages");
    case PluginCapabilityType::Analysis: return _u8L("Analysis");
    case PluginCapabilityType::Importer: return _u8L("Importer");
    case PluginCapabilityType::Exporter: return _u8L("Exporter");
    case PluginCapabilityType::Visualization: return _u8L("Visualization");
    case PluginCapabilityType::Script: return _u8L("Script");
    case PluginCapabilityType::SlicingPipeline: return _u8L("Slicing Pipeline");
    case PluginCapabilityType::ResourceTexture: return _u8L("Resource Texture");
    default: return _u8L("Unknown");
    }
}

References _u8L, Slic3r::Analysis, Slic3r::Exporter, Slic3r::Importer, Slic3r::Pages, Slic3r::PrinterConnection, Slic3r::ResourceTexture, Slic3r::Script, Slic3r::SlicingPipeline, and Slic3r::Visualization.

Referenced by Slic3r::GUI::anonymous_namespace{PluginsDialog.cpp}::build_plugin_dialog_item(), Slic3r::GUI::anonymous_namespace{PluginsDialog.cpp}::build_plugin_payload_item(), capabilities_payload(), Slic3r::PluginManager::check_registry_locked(), and Slic3r::plugin_loader::load().

Here is the caller graph for this function:

dirty()

bool Slic3r::PluginConfig::dirty

(

)

const

{
    std::lock_guard<std::mutex> lock(m_mutex);
    return m_dirty;
}

References m_dirty, and m_mutex.

erase_capability_config()

bool Slic3r::PluginConfig::erase_capability_config

(

const PluginCapabilityId &

id

)

{
    if (id.empty())
        return false;
 
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        if (!m_document.erase(id))
            return true;
        m_dirty = true;
    }
 
    return save();
}

References Slic3r::empty(), m_dirty, m_document, m_mutex, and save().

Here is the call graph for this function:

get_config()

std::optional< CapabilityConfigEntry > Slic3r::PluginConfig::get_config

(

const PluginCapabilityId &

id

)

const

{
    std::lock_guard<std::mutex> lock(m_mutex);
    return m_document.find(id);
}

References m_document, and m_mutex.

Referenced by get_config_response(), Slic3r::PresetPluginConfigService::get_effective_config(), restore_config_response(), and save_config_response().

Here is the caller graph for this function:

get_config_response()

nlohmann::json Slic3r::PluginConfig::get_config_response ( const PluginCapabilityId & id )

static

{
    nlohmann::json response;
    response["command"]         = "capability_config";
    response["plugin_key"]      = id.plugin_key;
    response["capability_name"] = id.name;
    response["capability_type"] = plugin_capability_type_to_string(id.type);
    response["config"]          = nlohmann::json::object();
    response["custom_html"]     = "";
    response["error"]           = "";
 
    // Scoped to the full identity, so a stale request from a page that has not caught up with a
    // refresh misses rather than reading a different plugin's config.
    const auto cap = PluginManager::instance().get_plugin_capability(id, false);
    if (!cap) {
        BOOST_LOG_TRIVIAL(warning) << "Ignoring config request for a capability that is no longer loaded. plugin_key="
                                   << id.plugin_key << " capability_name=" << id.name;
        response["error"] = GUI::into_u8(_L("This capability is no longer available."));
        return response;
    }
 
    if (const auto stored = PluginManager::instance().get_config().get_config(id))
        response["config"] = stored->config;
 
    if (cap->config_ui_available()) {
        // A raising or empty get_config_ui() costs the capability only its custom UI: report the
        // failure and let the page fall back to the default JSON editor over the same stored config.
        std::string html;
        std::string error;
        {
            wxBusyCursor busy;
            try {
                PythonGILState gil;
                html = cap->get_config_ui();
            } catch (const std::exception& ex) {
                error = ex.what();
            } catch (...) {
                error = _u8L("Unknown error");
            }
        }
 
        if (!error.empty()) {
            BOOST_LOG_TRIVIAL(error) << "Plugin capability get_config_ui() failed. plugin_key=" << id.plugin_key
                                     << " capability_name=" << id.name << " error=" << error;
            response["error"] = GUI::into_u8(GUI::format_wxstr(_L("The plugin's configuration UI failed to load (%1%). Showing the default editor."),
                                                     GUI::from_u8(error)));
        } else if (html.empty()) {
            BOOST_LOG_TRIVIAL(warning) << "Plugin capability reports a config UI but returned no HTML. plugin_key=" << id.plugin_key
                                       << " capability_name=" << id.name;
            response["error"] = GUI::into_u8(_L("The plugin's configuration UI was empty. Showing the default editor."));
        } else {
            response["custom_html"] = html;
        }
    }
 
    return response;
}

References _L, _u8L, Slic3r::GUI::format_wxstr(), Slic3r::GUI::from_u8(), get_config(), Slic3r::PluginManager::get_plugin_capability(), Slic3r::PluginManager::instance(), Slic3r::GUI::into_u8(), and Slic3r::plugin_capability_type_to_string().

Referenced by Slic3r::GUI::PluginsDialog::send_capability_config().

Here is the call graph for this function:

Here is the caller graph for this function:

has_config()

bool Slic3r::PluginConfig::has_config

(

const PluginCapabilityId &

id

)

const

{
    std::lock_guard<std::mutex> lock(m_mutex);
    return m_document.contains(id);
}

References m_document, and m_mutex.

load()

void Slic3r::PluginConfig::load

(

)

{
    const std::string path = plugin_config_file();
 
    std::lock_guard<std::mutex> lock(m_mutex);
    m_document = CapabilityConfigDocument();
    m_dirty = false;
 
    boost::system::error_code ec;
    if (!boost::filesystem::exists(path, ec))
        return;
 
    nlohmann::json root;
    try {
        boost::nowide::ifstream ifs(path.c_str());
        ifs >> root;
    } catch (const std::exception& err) {
        BOOST_LOG_TRIVIAL(error) << "PluginConfig: cannot read " << path << ": " << err.what() << "; starting with an empty config";
        return;
    }
 
    const auto entries = root.find(CapabilityConfigDocument::KeyEntries);
    if (entries == root.end() || !entries->is_array()) {
        BOOST_LOG_TRIVIAL(warning) << "PluginConfig: " << path << " has no \"" << CapabilityConfigDocument::KeyEntries
                                   << "\" array; starting with an empty config";
        return;
    }
 
    m_document = CapabilityConfigDocument::from_root_json(root);
}

References Slic3r::CapabilityConfigDocument::from_root_json(), Slic3r::CapabilityConfigDocument::KeyEntries, m_dirty, m_document, m_mutex, and plugin_config_file().

Here is the call graph for this function:

plugin_config_file()

const std::string Slic3r::PluginConfig::plugin_config_file ( )

inlinestatic

{ return (boost::filesystem::path(get_orca_plugins_dir()) / PLUGIN_CONFIG_DIR).string(); }

References Slic3r::get_orca_plugins_dir(), and PLUGIN_CONFIG_DIR.

Referenced by load(), and save().

Here is the call graph for this function:

Here is the caller graph for this function:

restore_config_response()

nlohmann::json Slic3r::PluginConfig::restore_config_response ( const PluginCapabilityId & id )

static

{
    nlohmann::json response;
    response["command"]         = "capability_config_saved";
    response["plugin_key"]      = id.plugin_key;
    response["capability_name"] = id.name;
    response["capability_type"] = plugin_capability_type_to_string(id.type);
    response["ok"]              = false;
    response["error"]           = "";
 
    const auto cap = PluginManager::instance().get_plugin_capability(id, false);
    if (!cap) {
        BOOST_LOG_TRIVIAL(warning) << "Refusing to restore config for a capability that is no longer loaded. plugin_key="
                                   << id.plugin_key << " capability_name=" << id.name;
        response["error"] = GUI::into_u8(_L("This capability is no longer available."));
        return response;
    }
 
    nlohmann::json defaults;
    std::string    error;
    {
        wxBusyCursor busy;
        try {
            PythonGILState gil;
            defaults = cap->get_default_config();
        } catch (const std::exception& ex) {
            error = ex.what();
        } catch (...) {
            error = _u8L("Unknown error");
        }
    }
 
    // A raising hook leaves the stored config as it was: better to restore nothing than to wipe the
    // user's settings on the strength of a broken plugin.
    if (!error.empty()) {
        BOOST_LOG_TRIVIAL(error) << "Plugin capability get_default_config() failed. plugin_key=" << id.plugin_key
                                 << " capability_name=" << id.name << " error=" << error;
        response["error"] = GUI::into_u8(GUI::format_wxstr(_L("The plugin could not supply a default configuration (%1%). "
                                                    "Nothing was changed."),
                                                 GUI::from_u8(error)));
        return response;
    }
 
    if (!PluginManager::instance().get_config().store_capability_config(id, defaults)) {
        BOOST_LOG_TRIVIAL(error) << "Failed to write the plugin config file while restoring defaults. plugin_key="
                                 << id.plugin_key << " capability_name=" << id.name;
        response["error"] = GUI::into_u8(_L("The configuration could not be written to disk. Nothing was changed."));
        return response;
    }
 
    BOOST_LOG_TRIVIAL(info) << "Restored default plugin capability config. plugin_key=" << id.plugin_key
                            << " capability_name=" << id.name;
 
    response["ok"]     = true;
    if (const auto stored = PluginManager::instance().get_config().get_config(id))
        response["config"] = stored->config;
    return response;
}

References _L, _u8L, Slic3r::GUI::format_wxstr(), Slic3r::GUI::from_u8(), get_config(), Slic3r::PluginManager::get_plugin_capability(), Slic3r::PluginManager::instance(), Slic3r::GUI::into_u8(), Slic3r::plugin_capability_type_to_string(), and store_capability_config().

Referenced by Slic3r::GUI::PluginsDialog::restore_capability_config().

Here is the call graph for this function:

Here is the caller graph for this function:

save()

bool Slic3r::PluginConfig::save

(

)

{
    const std::string path = plugin_config_file();
 
    std::lock_guard<std::mutex> lock(m_mutex);
    if (!m_dirty)
        return true;
 
    const nlohmann::json root = m_document.root_json();
 
    boost::system::error_code ec;
    boost::filesystem::create_directories(boost::filesystem::path(path).parent_path(), ec);
    if (ec) {
        BOOST_LOG_TRIVIAL(error) << "PluginConfig: cannot create the plugin directory: " << ec.message();
        return false;
    }
 
    // Written beside the target and moved into place, so a crash mid-write cannot truncate an
    // existing config.
    if (const std::error_code ec = write_file_atomically(path, root.dump(1, '\t') + "\n")) {
        BOOST_LOG_TRIVIAL(error) << "PluginConfig: failed to write " << path << ": " << ec.message() << "; keeping the existing config";
        return false;
    }
 
    m_dirty = false;
    return true;
}

References m_dirty, m_document, m_mutex, plugin_config_file(), and Slic3r::write_file_atomically().

Referenced by erase_capability_config(), and store_capability_config().

Here is the call graph for this function:

Here is the caller graph for this function:

save_config()

void Slic3r::PluginConfig::save_config

(

const CapabilityConfigEntry &

config

)

{
    if (config.id.empty()) {
        BOOST_LOG_TRIVIAL(error) << "PluginConfig: refusing to store a config without a complete capability identity";
        return;
    }
 
    std::lock_guard<std::mutex> lock(m_mutex);
    m_dirty = m_document.upsert(config) || m_dirty;
}

References Slic3r::PluginCapabilityId::empty(), Slic3r::CapabilityConfigEntry::id, m_dirty, m_document, and m_mutex.

Referenced by store_capability_config().

Here is the call graph for this function:

Here is the caller graph for this function:

save_config_response()

nlohmann::json Slic3r::PluginConfig::save_config_response ( const PluginCapabilityId & id, const nlohmann::json & config )

static

{
    nlohmann::json response;
    response["command"]         = "capability_config_saved";
    response["plugin_key"]      = id.plugin_key;
    response["capability_name"] = id.name;
    response["capability_type"] = plugin_capability_type_to_string(id.type);
    response["ok"]              = false;
    response["error"]           = "";
 
    const auto cap = PluginManager::instance().get_plugin_capability(id, false);
    if (!cap) {
        BOOST_LOG_TRIVIAL(warning) << "Refusing to save config for a capability that is no longer loaded. plugin_key="
                                   << id.plugin_key << " capability_name=" << id.name;
        response["error"] = GUI::into_u8(_L("This capability is no longer available. Your changes were not saved."));
        return response;
    }
 
    nlohmann::json parsed = config;
    if (config.is_string()) {
        // The page validates as the user types, but it is not the authority: re-parse so a malformed
        // document is rejected before it can reach config.json.
        parsed = nlohmann::json::parse(config.get<std::string>(), nullptr, /* allow_exceptions */ false);
        if (parsed.is_discarded()) {
            response["error"] = GUI::into_u8(_L("The configuration is not valid JSON. Your changes were not saved."));
            return response;
        }
    }
 
    if (!PluginManager::instance().get_config().store_capability_config(id, parsed)) {
        BOOST_LOG_TRIVIAL(error) << "Failed to write the plugin config file. plugin_key=" << id.plugin_key
                                 << " capability_name=" << id.name;
        response["error"] = GUI::into_u8(_L("The configuration could not be written to disk. Your changes were not saved."));
        return response;
    }
 
    BOOST_LOG_TRIVIAL(info) << "Saved plugin capability config. plugin_key=" << id.plugin_key << " capability_name=" << id.name;
 
    // Echo back what was persisted, not what the user typed, so the editor reloads from the store.
    response["ok"]     = true;
    if (const auto stored = PluginManager::instance().get_config().get_config(id))
        response["config"] = stored->config;
    return response;
}

References _L, get_config(), Slic3r::PluginManager::get_plugin_capability(), Slic3r::PluginManager::instance(), Slic3r::GUI::into_u8(), Slic3r::plugin_capability_type_to_string(), and store_capability_config().

Referenced by Slic3r::GUI::PluginsDialog::save_capability_config().

Here is the call graph for this function:

Here is the caller graph for this function:

store_capability_config()

bool Slic3r::PluginConfig::store_capability_config	(	const PluginCapabilityId &	id,
		const nlohmann::json &	config )

{
    if (id.empty())
        return false;
 
    save_config({id, running_plugin_version(id.plugin_key), config});
    return save();
}

References Slic3r::empty(), save(), and save_config().

Referenced by Slic3r::capability_save_config(), restore_config_response(), and save_config_response().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_dirty

bool Slic3r::PluginConfig::m_dirty = false

private

Referenced by dirty(), erase_capability_config(), load(), save(), and save_config().

m_document

CapabilityConfigDocument Slic3r::PluginConfig::m_document

private

Referenced by erase_capability_config(), get_config(), has_config(), load(), save(), and save_config().

m_mutex

std::mutex Slic3r::PluginConfig::m_mutex

mutableprivate

Referenced by dirty(), erase_capability_config(), get_config(), has_config(), load(), save(), and save_config().

---

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

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