cleanup

src/slic3r/plugin/PluginResolver.hpp

@@ -24,10 +24,9 @@ struct MissingPlugin
     PluginCapabilityType type{PluginCapabilityType::Unknown};
 };
 
-// Rebuild the missing-plugin set owned by a single preset type from that preset's "plugins"
-// manifest, comparing each ref against the live plugin catalog and loaded/enabled capabilities. A
-// null/empty manifest clears the set for that type. Only TYPE_PRINT (process), TYPE_PRINTER
-// (machine) and TYPE_FILAMENT are tracked; other types are ignored.
+// Rebuild one preset type's missing-plugin set from its "plugins" manifest, comparing each ref
+// against the live catalog and loaded/enabled capabilities. A null/empty manifest clears the set.
+// Only TYPE_PRINT, TYPE_PRINTER and TYPE_FILAMENT are tracked.
 void refresh_missing_plugins(Preset::Type type, const ConfigOptionStrings* manifest, const Preset* preset = nullptr);
 void refresh_missing_plugins(const PresetBundle& preset_bundle);
 
@@ -37,22 +36,16 @@ std::vector<MissingPlugin> get_missing_cloud_plugins();
 std::vector<MissingPlugin> get_missing_local_plugins();
 bool                     has_missing_plugins();
 
-// Installed-but-inactive capabilities: the plugin has a local package but the referenced capability
-// is not active because the plugin is not loaded, or it is loaded but the capability is disabled.
-// Resolved locally by loading the plugin and/or enabling the capability — no download.
+// Installed-but-inactive: the plugin has a local package but is not loaded, or is loaded with the
+// capability disabled. Resolved locally by loading and/or enabling — no download.
 std::vector<MissingPlugin> get_inactive_plugins();
 bool                     has_inactive_plugins();
 
 // Broken references: the plugin is installed AND loaded but does not provide the referenced
-// capability at all (renamed/removed/outdated plugin). Activation cannot fix these; surfaced as an
-// informational notification pointing the user at OrcaCloud to update the plugin.
+// capability at all (renamed/removed/outdated plugin). Activation cannot fix these.
 std::vector<MissingPlugin> get_broken_plugins();
 bool                     has_broken_plugins();
 
-// Resolution actions invoked from the missing-plugin notifications:
-// - cloud refs are subscribed/installed and loaded on a detached worker thread; failures are
-//   reported through a non-blocking notification. Non-cloud refs are ignored.
-
 // Optional progress hook for the cloud install worker. All three callbacks fire on the worker
 // thread; implementations must only touch thread-safe state or marshal to the UI thread.
 struct PluginInstallProgress
@@ -65,43 +58,39 @@ struct PluginInstallProgress
     std::function<void()> on_finished;
 };
 
-// Cloud refs only; local refs are handled via the browser flow. `progress` is optional — a
-// default-constructed value preserves the previous silent behavior.
+// Subscribe, install and load the cloud refs on a detached worker; failures are reported through a
+// non-blocking notification. Local refs are ignored — they go through the browser flow below.
 void resolve_missing_plugins(const std::vector<std::string>& refs,
                              PluginInstallProgress progress = {});
 
-// Activate inactive plugins: load each referenced plugin (passing the capabilities to enable) and/or
-// enable already-loaded-but-disabled capabilities. Local only — no network. The loads run on a
-// background worker that waits for them and then re-validates the plate, clearing the notification
-// (or reclassifying the ref as broken if the loaded plugin turns out not to provide the capability).
+// Load each referenced plugin and/or enable its disabled capabilities. Local only — no network. The
+// loads run on a background worker that waits for them and then re-validates the plate, clearing the
+// notification (or reclassifying the ref as broken if the plugin does not provide the capability).
 void resolve_inactive_plugins(const std::vector<std::string>& refs);
 
-// - local refs are opened on the OrcaCloud plugin hub (search when exactly one ref, hub otherwise).
+// Opens the OrcaCloud plugin hub (a search when there is exactly one ref, the hub otherwise).
 void open_missing_plugins_on_cloud(const std::vector<std::string>& local_refs);
 
 std::string create_full_ref(const PluginCapabilityRef& ref);
 std::string resolve_recovery_url(const PluginCapabilityRef& ref);
 
 // The capabilities `preset`'s "plugins" manifest declares AND that one of its plugin-backed options
-// (ConfigOptionDef::is_plugin_backed) currently references. A manifest entry nobody points at is not
-// in use. Pure preset logic — the plugin catalog and loader are not consulted. Empty for untracked
-// preset types.
+// (ConfigOptionDef::is_plugin_backed) currently references: a manifest entry nobody points at is not
+// in use. Pure preset logic — the catalog and loader are not consulted. Empty for untracked types.
 std::vector<PluginCapabilityRef> referenced_capabilities(Preset::Type type, const Preset& preset);
 std::vector<PluginCapabilityIdentifier> capabilities_in_use(Preset::Type type, const Preset& preset);
 
-// The preset type that owns capabilities of `type` — the one whose presets can reference them and
-// therefore carry their overrides. Derived from the ConfigDef rather than hardcoded: a plugin-backed
-// option names the capability type it accepts (ConfigOptionDef::plugin_type) and belongs to exactly
-// one preset type, so declaring the option is all it takes to map a new capability type.
-// TYPE_INVALID when no option accepts the type (nothing can reference it, so no preset owns it).
+// The preset type whose presets can reference capabilities of `type` and therefore carry their
+// overrides. Derived from the ConfigDef rather than hardcoded: a plugin-backed option names the
+// capability type it accepts (ConfigOptionDef::plugin_type) and belongs to exactly one preset type,
+// so declaring the option is all it takes to map a new capability type. TYPE_INVALID when no option
+// accepts the type — nothing can reference it, so no preset owns it.
 Preset::Type preset_type_for_capability(PluginCapabilityType type);
 
-// The capabilities the active preset(s) of `type` reference (see referenced_capabilities) and that
-// are loaded right now: the set that can actually be configured. Missing and broken refs are absent,
-// having no instance to ask for a config UI or defaults. A loaded-but-disabled capability IS listed —
-// it still has stored config worth editing, and disabling it is not a reason to hide that.
-// TYPE_FILAMENT unions every selected filament preset; a capability used by two extruders is listed
-// once. Deduped on the full identity, so two plugins exposing a same-named capability stay distinct.
+// The referenced capabilities of the active preset(s) of `type` that are loaded right now: the set
+// that can actually be configured. Missing and broken refs are absent, having no instance to ask for
+// a config UI or defaults. A loaded-but-disabled capability IS listed — it still has stored config
+// worth editing.
 std::vector<PluginCapabilityIdentifier> capabilities_in_use(const PresetBundle& preset_bundle, Preset::Type type);
 
 bool check_capability_in_use(const std::string& capability_refs);