Slic3r::plugin_loader::anonymous_namespace{PluginLoader.cpp} Namespace Reference

Functions
boost::filesystem::path	canonical_or_absolute (const boost::filesystem::path &path)
std::string	plugin_package_extension (const boost::filesystem::path &path)
boost::filesystem::path	local_plugin_root ()
boost::filesystem::path	local_plugin_install_dir (const boost::filesystem::path &source_path)
void	assign_local_plugin_key (PluginDescriptor &plugin_descriptor, const boost::filesystem::path &entry_file)
bool	read_local_plugin_package_metadata (const boost::filesystem::path &source_path, PluginDescriptor &plugin_descriptor, std::string &error)
void	teardown_capabilities (std::vector< std::shared_ptr< PluginCapabilityInterface > > &capabilities, std::size_t lifecycle_count)
bool	add_wheel_dependencies_to_sys_path (const PluginDescriptor &descriptor, std::vector< std::string > &plugin_paths, std::string &error)
PyObject *	import_plugin_module (const PluginDescriptor &descriptor, std::vector< std::string > &plugin_paths, std::vector< std::string > &plugin_modules, std::string &error)
std::string	plugin_module_name (const PluginDescriptor &descriptor)

Function Documentation

add_wheel_dependencies_to_sys_path()

bool Slic3r::plugin_loader::anonymous_namespace{PluginLoader.cpp}::add_wheel_dependencies_to_sys_path	(	const PluginDescriptor &	descriptor,
		std::vector< std::string > &	plugin_paths,
		std::string &	error )

{
    namespace fs = boost::filesystem;
 
    const fs::path entry_path(descriptor.entry_path);
    const fs::path plugin_dir = entry_path.has_extension() ? entry_path.parent_path() : entry_path;
    if (!fs::exists(plugin_dir) || !fs::is_directory(plugin_dir))
        return true;
 
    PythonInterpreter& interpreter = PythonInterpreter::instance();
    for (fs::directory_iterator it(plugin_dir); it != fs::directory_iterator(); ++it) {
        if (!fs::is_regular_file(it->status()) || it->path().extension() != ".whl")
            continue;
        // Skip the entry file itself — it is loaded by its own path.
        if (it->path() == entry_path)
            continue;
 
        const fs::path dep_dir = plugin_dir / "__whl_extracted__" / it->path().stem().string();
        if (!fs::exists(dep_dir)) {
            std::string extract_error;
            if (!extract_zip_to_directory(it->path(), dep_dir, extract_error)) {
                // TRN %1% is the dependency file, %2% the error detail.
                error = GUI::format(_u8L("Failed to extract plugin .whl dependency %1%: %2%"), it->path().string(), extract_error);
                return false;
            }
        }
 
        std::string syspath_error;
        if (!interpreter.add_plugin_sys_path(dep_dir.string(), syspath_error)) {
            error = GUI::format(_u8L("Failed to add .whl dependency to sys.path: %1%"), syspath_error);
            return false;
        }
        plugin_paths.push_back(dep_dir.string());
    }
 
    return true;
}

References _u8L, Slic3r::PythonInterpreter::add_plugin_sys_path(), add_wheel_dependencies_to_sys_path(), Slic3r::PluginDescriptor::entry_path, Slic3r::extract_zip_to_directory(), Slic3r::GUI::format(), and Slic3r::PythonInterpreter::instance().

Referenced by add_wheel_dependencies_to_sys_path().

Here is the call graph for this function:

Here is the caller graph for this function:

assign_local_plugin_key()

void Slic3r::plugin_loader::anonymous_namespace{PluginLoader.cpp}::assign_local_plugin_key	(	PluginDescriptor &	plugin_descriptor,
		const boost::filesystem::path &	entry_file )

{
    plugin_descriptor.plugin_key = make_local_plugin_key(entry_file.stem().string());
}

References assign_local_plugin_key(), Slic3r::make_local_plugin_key(), and Slic3r::PluginDescriptor::plugin_key.

Referenced by assign_local_plugin_key().

Here is the call graph for this function:

Here is the caller graph for this function:

canonical_or_absolute()

boost::filesystem::path Slic3r::plugin_loader::anonymous_namespace{PluginLoader.cpp}::canonical_or_absolute

(

const boost::filesystem::path &

path

)

{
    namespace fs = boost::filesystem;
 
    boost::system::error_code ec;
    fs::path resolved = fs::weakly_canonical(path, ec);
    if (!ec && !resolved.empty())
        return resolved;
 
    ec.clear();
    resolved = fs::absolute(path, ec);
    if (!ec && !resolved.empty())
        return resolved;
 
    return path;
}

References canonical_or_absolute().

Referenced by canonical_or_absolute().

Here is the call graph for this function:

Here is the caller graph for this function:

import_plugin_module()

PyObject * Slic3r::plugin_loader::anonymous_namespace{PluginLoader.cpp}::import_plugin_module	(	const PluginDescriptor &	descriptor,
		std::vector< std::string > &	plugin_paths,
		std::vector< std::string > &	plugin_modules,
		std::string &	error )

{
    PythonInterpreter& interpreter = PythonInterpreter::instance();
 
    if (descriptor.entry_package.empty())
        return interpreter.load_module_from_file(descriptor.entry_path, error, &plugin_paths, &plugin_modules);
 
    if (boost::filesystem::path(descriptor.entry_path).extension() == ".whl")
        return interpreter.load_module_from_whl(
            descriptor.entry_path, descriptor.entry_package, error, &plugin_paths, &plugin_modules);
 
    return interpreter.load_module_from_directory(
        descriptor.entry_path, descriptor.entry_package, error, &plugin_paths, &plugin_modules);
}

References Slic3r::PluginDescriptor::entry_package, Slic3r::PluginDescriptor::entry_path, import_plugin_module(), Slic3r::PythonInterpreter::instance(), Slic3r::PythonInterpreter::load_module_from_directory(), Slic3r::PythonInterpreter::load_module_from_file(), and Slic3r::PythonInterpreter::load_module_from_whl().

Referenced by import_plugin_module().

Here is the call graph for this function:

Here is the caller graph for this function:

local_plugin_install_dir()

boost::filesystem::path Slic3r::plugin_loader::anonymous_namespace{PluginLoader.cpp}::local_plugin_install_dir

(

const boost::filesystem::path &

source_path

)

{
    // Folder name follows the plugin filename and is the install/backup conflict unit;
    // plugin_key is the file stem of the same file.
    return local_plugin_root() / filesystem_safe_escape(source_path.filename().string());
}

References Slic3r::filesystem_safe_escape(), local_plugin_install_dir(), and local_plugin_root().

Referenced by local_plugin_install_dir().

Here is the call graph for this function:

Here is the caller graph for this function:

local_plugin_root()

boost::filesystem::path Slic3r::plugin_loader::anonymous_namespace{PluginLoader.cpp}::local_plugin_root

(

)

{
    return boost::filesystem::path(data_dir()) / "orca_plugins";
}

References Slic3r::data_dir(), and local_plugin_root().

Referenced by local_plugin_install_dir(), and local_plugin_root().

Here is the call graph for this function:

Here is the caller graph for this function:

plugin_module_name()

std::string Slic3r::plugin_loader::anonymous_namespace{PluginLoader.cpp}::plugin_module_name

(

const PluginDescriptor &

descriptor

)

{
    if (!descriptor.entry_package.empty())
        return descriptor.entry_package;
    return boost::filesystem::path(descriptor.entry_path).stem().string();
}

References Slic3r::PluginDescriptor::entry_package, Slic3r::PluginDescriptor::entry_path, and plugin_module_name().

Referenced by plugin_module_name().

Here is the call graph for this function:

Here is the caller graph for this function:

plugin_package_extension()

std::string Slic3r::plugin_loader::anonymous_namespace{PluginLoader.cpp}::plugin_package_extension

(

const boost::filesystem::path &

path

)

{
    std::string ext = path.extension().string();
    boost::algorithm::to_lower(ext);
    return ext;
}

References plugin_package_extension().

Referenced by plugin_package_extension(), and read_local_plugin_package_metadata().

Here is the call graph for this function:

Here is the caller graph for this function:

read_local_plugin_package_metadata()

bool Slic3r::plugin_loader::anonymous_namespace{PluginLoader.cpp}::read_local_plugin_package_metadata	(	const boost::filesystem::path &	source_path,
		PluginDescriptor &	plugin_descriptor,
		std::string &	error )

{
    error.clear();
 
    const std::string ext = plugin_package_extension(source_path);
    if (ext != ".py" && ext != ".whl") {
        error = GUI::format(_u8L("Plugin package must be a .py or .whl file, got: %1%"), ext);
        return false;
    }
 
    bool ok = false;
    if (ext == ".whl")
        ok = read_wheel_plugin_metadata(source_path, plugin_descriptor, error);
    else
        ok = read_python_plugin_metadata(source_path, plugin_descriptor, error);
 
    if (!ok)
        return false;
 
    plugin_descriptor.cloud = std::nullopt;
    return true;
}

References _u8L, Slic3r::PluginDescriptor::cloud, Slic3r::GUI::format(), plugin_package_extension(), read_local_plugin_package_metadata(), Slic3r::read_python_plugin_metadata(), and Slic3r::read_wheel_plugin_metadata().

Referenced by read_local_plugin_package_metadata().

Here is the call graph for this function:

Here is the caller graph for this function:

teardown_capabilities()

void Slic3r::plugin_loader::anonymous_namespace{PluginLoader.cpp}::teardown_capabilities	(	std::vector< std::shared_ptr< PluginCapabilityInterface > > &	capabilities,
		std::size_t	lifecycle_count )

{
    if (capabilities.empty())
        return;
 
    if (!PythonInterpreter::instance().is_initialized()) {
        capabilities.clear();
        return;
    }
 
    PythonGILState gil;
    if (!gil) {
        capabilities.clear();
        return;
    }
 
    lifecycle_count = std::min(lifecycle_count, capabilities.size());
    for (std::size_t index = 0; index < lifecycle_count; ++index) {
        const auto& capability = capabilities[index];
        if (!capability)
            continue;
        try {
            capability->on_unload();
        } catch (const std::exception& ex) {
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": Plugin on_unload failed: " << ex.what();
        } catch (...) {
            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": Plugin on_unload failed";
        }
    }
    capabilities.clear();
}

References Slic3r::PythonInterpreter::instance(), and teardown_capabilities().

Referenced by teardown_capabilities().

Here is the call graph for this function:

Here is the caller graph for this function: