Slic3r::plugin_hooks::anonymous_namespace{PluginHooks.cpp} Namespace Reference

Functions
void	install_capability_resolver ()
void	install_lifecycle_event_hook ()
void	install_slicing_pipeline_hook ()

Function Documentation

install_capability_resolver()

void Slic3r::plugin_hooks::anonymous_namespace{PluginHooks.cpp}::install_capability_resolver

(

)

{
    ConfigBase::set_resolve_capability_fn([](const std::string& cap_name, const std::string& cap_type) {
        PluginManager& plugin_mgr = PluginManager::instance();
        const PluginCapabilityType type = plugin_capability_type_from_string(cap_type);
        // only_enabled = false: this resolves the reference a preset STORES, which must stay
        // resolvable whether or not the user currently has the capability enabled. Filtering on
        // the enable flag here would quietly drop the reference out of the preset's manifest.
        auto plugin_cap = plugin_mgr.get_plugin_capability(cap_name, type, /*only_enabled=*/false);
        if (!plugin_cap)
            return std::string();
 
        PluginDescriptor descriptor;
        if (!plugin_mgr.try_get_plugin_descriptor_for_capability(cap_name, type, descriptor))
            return std::string();
 
        // Cloud plugins are resolved at runtime via the UUID in the middle field, so the first
        // field keeps the friendly display name. Local plugins are looked up by plugin_key (the
        // first field, with an empty UUID), so emit the plugin_key to keep them resolvable.
        const std::string identity = descriptor.is_cloud_plugin() ? descriptor.name : descriptor.plugin_key;
        return identity + ';' + descriptor.cloud_uuid() + ';' + cap_name;
    });
}

References Slic3r::PluginDescriptor::cloud_uuid(), Slic3r::PluginManager::get_plugin_capability(), Slic3r::identity(), install_capability_resolver(), Slic3r::PluginManager::instance(), Slic3r::PluginDescriptor::is_cloud_plugin(), Slic3r::PluginDescriptor::name, Slic3r::plugin_capability_type_from_string(), Slic3r::PluginDescriptor::plugin_key, Slic3r::ConfigBase::set_resolve_capability_fn(), and Slic3r::PluginManager::try_get_plugin_descriptor_for_capability().

Referenced by install_capability_resolver().

Here is the call graph for this function:

Here is the caller graph for this function:

install_lifecycle_event_hook()

void Slic3r::plugin_hooks::anonymous_namespace{PluginHooks.cpp}::install_lifecycle_event_hook

(

)

{
    set_lifecycle_hook_fn([](LifecycleEvent event, const LifecycleEventContext& ctx) {
        PluginManager::instance().dispatch_lifecycle_event(event, ctx);
    });
}

References Slic3r::PluginManager::dispatch_lifecycle_event(), install_lifecycle_event_hook(), Slic3r::PluginManager::instance(), and Slic3r::set_lifecycle_hook_fn().

Referenced by install_lifecycle_event_hook().

Here is the call graph for this function:

Here is the caller graph for this function:

install_slicing_pipeline_hook()

void Slic3r::plugin_hooks::anonymous_namespace{PluginHooks.cpp}::install_slicing_pipeline_hook

(

)

{
    Print::set_slicing_pipeline_hook_fn(
        [](Print& print, const PrintObject* object, SlicingPipelineStepPlugin step) {
            const auto* caps  = print.config().option<ConfigOptionStrings>("slicing_pipeline_plugin");
            // `plugins` is a dynamic-only manifest key (not a static PrintConfig member), so it
            // must be read from the full/dynamic config -- reading it off print.config() (the
            // static PrintConfig) always yields nullptr and skips every capability. Mirrors the
            // post-process path (PostProcessor.cpp, via BackgroundSlicingProcess::full_print_config()).
            const auto* plugs = print.full_print_config().option<ConfigOptionStrings>("plugins");
            if (caps == nullptr || caps->values.empty())
                return;
 
            execute_capabilities_from_refs<SlicingPipelinePluginCapability>(
                *caps, plugs, PluginCapabilityType::SlicingPipeline,
                [&](std::shared_ptr<SlicingPipelinePluginCapability> cap, const PluginCapabilityRef& ref) {
                    const std::string plugin_key = ref.uuid.empty() ? ref.name : ref.uuid;
                    ExecutionResult r;
                    try {
                        // GIL is acquired per capability (not once for the whole dispatch) so it
                        // is released between capabilities.
                        PythonGILState gil;
                        if (!gil)
                            throw std::runtime_error("Python interpreter is shutting down");
                        // throw_if_canceled() is protected on PrintBase; canceled() is the public
                        // equivalent check (same cancel flag), so honor cancellation via it.
                        if (print.canceled())
                            throw CanceledException();
                        SlicingPipelineContext ctx;
                        ctx.orca_version = SoftFever_VERSION;
                        ctx.step   = step;
                        ctx.print  = &print;
                        ctx.object = object;
                        // Slicing hooks are synchronous by design and never await: the context
                        // borrows Print/PrintObject that are only valid during this call, and the
                        // UI thread may itself be blocked waiting on this slicing worker. An async
                        // override is rejected here rather than scheduled -- cap->execute() casts
                        // its Python result to ExecutionResult and a coroutine object cannot be
                        // cast, so it surfaces as the SlicingError below.
                        r = cap->execute(ctx);
                    } catch (const CanceledException&) {
                        throw; // cancellation must reach process(), never become a slicing error
                    } catch (const std::exception& ex) {
                        // A Python raise reaches here as pybind11::error_already_set; surface it as a
                        // (non-critical) slicing error instead of a crash.
                        throw SlicingError(GUI::format(_u8L("Slicing pipeline plugin '%1%' error: %2%"),
                                                       ref.capability_name, ex.what()));
                    }
                    if (r.status == PluginResult::FatalError)
                        throw SlicingError(GUI::format(_u8L("Slicing pipeline plugin '%1%' error: %2%"),
                                                       ref.capability_name, r.message));
                    // log a non-empty success/skipped message instead of dropping it. This is
                    // log-only by design: every pipeline hook fires AFTER set_done() (see Print.cpp),
                    // so the Print-level m_step_active is -1 here. Calling active_step_add_warning()
                    // would then index m_state[-1] (out-of-bounds; the guarding assert is compiled
                    // out in Release), so it must NOT be called from a pipeline hook.
                    if (!r.message.empty()) {
                        static const char* const kStepNames[] = {
                            "posSlice", "posPerimeters", "posEstimateCurledExtrusions", "posPrepareInfill", "posInfill",
                            "posIroning", "posContouring", "posSupportMaterial", "posDetectOverhangsForLift",
                            "posSimplifyPath", "psWipeTower", "psSkirtBrim", "psGCodePostProcess"
                        }; // order must match SlicingPipelineStepPlugin
                        const char* step_name = static_cast<size_t>(step) < sizeof(kStepNames) / sizeof(kStepNames[0])
                                                    ? kStepNames[static_cast<int>(step)] : "Unknown";
                        BOOST_LOG_TRIVIAL(info) << "Slicing pipeline plugin '" << ref.capability_name
                                                << "' [" << step_name << "]: " << r.message;
                    }
                });
        });
}

References _u8L, Slic3r::PrintBase::canceled(), Slic3r::PluginCapabilityRef::capability_name, Slic3r::Print::config(), Slic3r::execute_capabilities_from_refs(), Slic3r::FatalError, Slic3r::GUI::format(), Slic3r::PrintBase::full_print_config(), install_slicing_pipeline_hook(), Slic3r::ExecutionResult::message, Slic3r::PluginCapabilityRef::name, Slic3r::SlicingPipelineContext::object, Slic3r::ConfigBase::option(), Slic3r::SlicingPipelineContext::orca_version, Slic3r::SlicingPipelineContext::print, Slic3r::Print::set_slicing_pipeline_hook_fn(), Slic3r::SlicingPipeline, Slic3r::ExecutionResult::status, Slic3r::SlicingPipelineContext::step, and Slic3r::PluginCapabilityRef::uuid.

Referenced by install_slicing_pipeline_hook().

Here is the call graph for this function:

Here is the caller graph for this function: