Merge branch 'feat/plugin-feature' into feature/plugin-slicing

Brings in the Plugins dialog as-you-type search with fuzzy match highlighting
and clickable column-header sorting (name, version, source, status) — PRs
#14610 and #14611.

src/slic3r/CMakeLists.txt

@@ -109,6 +109,9 @@ set(SLIC3R_GUI_SOURCES
     GUI/Downloader.hpp
     GUI/DownloadProgressDialog.cpp
     GUI/DownloadProgressDialog.hpp
+    GUI/PluginSource.hpp
+    GUI/PluginSort.hpp
+    GUI/PluginStatus.hpp
     GUI/PluginPickerDialog.cpp
     GUI/PluginPickerDialog.hpp
     GUI/PluginsDialog.cpp

src/slic3r/GUI/PluginSort.hpp

@@ -0,0 +1,210 @@
+#pragma once
+
+#include "PluginSource.hpp"
+#include "PluginStatus.hpp"
+
+#include "libslic3r/Semver.hpp"
+
+#include <algorithm>
+#include <cctype>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace Slic3r::GUI
+{
+    enum class PluginSortKey
+    {
+        Status,
+        Name,
+        Source,
+        Version,
+        // why: neutral "no column selected" state - clearing a header sort returns here and the
+        //   list falls to compare_plugin_base_order only. Header UI reaches it via the asc/desc/clear cycle.
+        None
+    };
+
+    enum class PluginSortOrder
+    {
+        Asc,
+        Desc
+    };
+
+    inline std::string to_string(PluginSortKey sort_key)
+    {
+        switch (sort_key)
+        {
+        case PluginSortKey::Status: return "status";
+        case PluginSortKey::Name: return "name";
+        case PluginSortKey::Source: return "source";
+        case PluginSortKey::Version: return "version";
+        case PluginSortKey::None: return "none";
+        }
+
+        return "status";
+    }
+
+    inline std::string to_string(PluginSortOrder sort_order)
+    {
+        return sort_order == PluginSortOrder::Desc ? "desc" : "asc";
+    }
+
+    inline PluginSortKey plugin_sort_key_from_string(const std::string& sort_key, PluginSortKey fallback)
+    {
+        if (sort_key == "status")
+            return PluginSortKey::Status;
+        if (sort_key == "name")
+            return PluginSortKey::Name;
+        if (sort_key == "source")
+            return PluginSortKey::Source;
+        if (sort_key == "version")
+            return PluginSortKey::Version;
+        if (sort_key == "none")
+            return PluginSortKey::None;
+        return fallback;
+    }
+
+    inline PluginSortOrder plugin_sort_order_from_string(const std::string& sort_order, PluginSortOrder fallback)
+    {
+        if (sort_order == "asc")
+            return PluginSortOrder::Asc;
+        if (sort_order == "desc")
+            return PluginSortOrder::Desc;
+        return fallback;
+    }
+
+    // Natural, case-insensitive ASCII compare returning -1 / 0 / +1. Digit runs compare by
+    // numeric value; other chars compare lowercased; on a prefix tie the shorter string is less.
+    //   e.g. "item2"  < "item10"   (2 < 10, not '2' > '1')
+    //        "Camera" == "camera"  (case ignored)
+    //        "app"    < "apple"    (prefix is shorter)
+    //        "1"      < "01"       (equal value, fewer leading zeros wins the tie)
+    // note: ASCII only - no locale/Unicode; accented or non-Latin names fall back to byte order.
+    inline int compare_ascii_case_insensitive_natural(const std::string& lhs, const std::string& rhs)
+    {
+        std::size_t li = 0;
+        std::size_t ri = 0;
+
+        while (li < lhs.size() && ri < rhs.size())
+        {
+            const unsigned char lc = static_cast<unsigned char>(lhs[li]);
+            const unsigned char rc = static_cast<unsigned char>(rhs[ri]);
+
+            if (std::isdigit(lc) && std::isdigit(rc))
+            {
+                const std::size_t lhs_digit_begin = li;
+                const std::size_t rhs_digit_begin = ri;
+                while (li < lhs.size() && std::isdigit(static_cast<unsigned char>(lhs[li])))
+                    ++li;
+                while (ri < rhs.size() && std::isdigit(static_cast<unsigned char>(rhs[ri])))
+                    ++ri;
+
+                const std::string_view lhs_run(lhs.data() + lhs_digit_begin, li - lhs_digit_begin);
+                const std::string_view rhs_run(rhs.data() + rhs_digit_begin, ri - rhs_digit_begin);
+                // why: digit runs compare numerically; leading zeros only break exact ties ("1" < "01").
+                const std::string_view lhs_num = lhs_run.substr(std::min(lhs_run.find_first_not_of('0'), lhs_run.size()));
+                const std::string_view rhs_num = rhs_run.substr(std::min(rhs_run.find_first_not_of('0'), rhs_run.size()));
+                if (lhs_num.size() != rhs_num.size())
+                    return lhs_num.size() < rhs_num.size() ? -1 : 1;
+                if (const int cmp = lhs_num.compare(rhs_num); cmp != 0)
+                    return cmp;
+                // note: fewer-leading-zeros-first is our convention, not an industry standard (impls
+                //   diverge here); it only matters as a deterministic total order for unstable std::sort.
+                if (lhs_run.size() != rhs_run.size())
+                    return lhs_run.size() < rhs_run.size() ? -1 : 1;
+                continue;
+            }
+
+            const int lower_lhs = std::tolower(lc);
+            const int lower_rhs = std::tolower(rc);
+            if (lower_lhs != lower_rhs)
+                return lower_lhs < lower_rhs ? -1 : 1;
+
+            ++li;
+            ++ri;
+        }
+
+        if (li == lhs.size() && ri == rhs.size())
+            return 0;
+        return li == lhs.size() ? -1 : 1;
+    }
+
+    // Neutral baseline order: the whole order when no column is sorted, and the tie-breaker under
+    // every primary sort key. Name-first so the default view is intuitively alphabetical:
+    // name, then source, then status, then type, with plugin_key as the final deterministic tie.
+    //   e.g. with no column sorted the list reads A..Z by name.
+    template <class PluginItem>
+    int compare_plugin_base_order(const PluginItem& lhs, const PluginItem& rhs)
+    {
+        if (const int cmp = compare_ascii_case_insensitive_natural(lhs.display_name, rhs.display_name); cmp != 0)
+            return cmp;
+        if (const int cmp = static_cast<int>(lhs.source) - static_cast<int>(rhs.source); cmp != 0)
+            return cmp;
+        if (const int cmp = static_cast<int>(lhs.status) - static_cast<int>(rhs.status); cmp != 0)
+            return cmp;
+        if (const int cmp = lhs.type_key.compare(rhs.type_key); cmp != 0)
+            return cmp;
+        return lhs.plugin_key.compare(rhs.plugin_key);
+    }
+
+    // Compares two version strings returning -1 / 0 / +1. Uses Slic3r::Semver (the same parser the
+    // plugin catalog's update-available check uses); on unparseable input falls back to the natural
+    // compare so the order stays deterministic.
+    //   e.g. "1.2.0" < "1.10.0" (numeric), "1.0.0-rc1" < "1.0.0" (semver prerelease rule).
+    inline int compare_plugin_version(const std::string& lhs, const std::string& rhs)
+    {
+        const auto lhs_semver = Semver::parse(lhs);
+        const auto rhs_semver = Semver::parse(rhs);
+        if (lhs_semver && rhs_semver)
+        {
+            if (*lhs_semver < *rhs_semver) return -1;
+            if (*rhs_semver < *lhs_semver) return 1;
+            return 0;
+        }
+        return compare_ascii_case_insensitive_natural(lhs, rhs);
+    }
+
+    // Compares two items by the chosen primary key, returning -1 / 0 / +1. Status and Source
+    // rank by enum ordinal (the declared dialog priority); Name uses the natural compare above.
+    //   e.g. Status: an enabled item (lower ordinal) sorts before a disabled one.
+    //        Name:   "Plugin 2" sorts before "Plugin 10".
+    template <class PluginItem>
+    int compare_plugin_sort_key(const PluginItem& lhs, const PluginItem& rhs, PluginSortKey sort_key)
+    {
+        switch (sort_key)
+        {
+        case PluginSortKey::Status:
+            // why: PluginStatus/PluginSource declare the dialog sort priority as their ordinal order.
+            return static_cast<int>(lhs.status) - static_cast<int>(rhs.status);
+        case PluginSortKey::Name:
+            return compare_ascii_case_insensitive_natural(lhs.display_name, rhs.display_name);
+        case PluginSortKey::Source:
+            return static_cast<int>(lhs.source) - static_cast<int>(rhs.source);
+        case PluginSortKey::Version:
+            return compare_plugin_version(lhs.sort_version, rhs.sort_version);
+        case PluginSortKey::None:
+            // why: no primary key - every pair ties here so sort_plugin_items_for_dialog falls
+            //   straight to the ascending base order (direction is irrelevant for the baseline).
+            return 0;
+        }
+
+        return 0;
+    }
+
+    // Sorts the dialog list in place by primary key + direction. Ties always fall back to the
+    // ascending base order, so the result is deterministic regardless of the primary direction.
+    //   e.g. sort_key=Name, order=Desc -> names Z..A, but equal names keep the stable base order.
+    template <class PluginItem>
+    void sort_plugin_items_for_dialog(std::vector<PluginItem>& items, PluginSortKey sort_key,
+                                      PluginSortOrder sort_order)
+    {
+        std::sort(items.begin(), items.end(),
+                  [sort_key, sort_order](const PluginItem& lhs, const PluginItem& rhs)
+                  {
+                      if (const int cmp = compare_plugin_sort_key(lhs, rhs, sort_key); cmp != 0)
+                          return sort_order == PluginSortOrder::Asc ? cmp < 0 : cmp > 0;
+                      // why: ties fall back to ascending base order regardless of the primary direction.
+                      return compare_plugin_base_order(lhs, rhs) < 0;
+                  });
+    }
+} // namespace Slic3r::GUI

src/slic3r/GUI/PluginSource.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <string>
+
+namespace Slic3r
+{
+    namespace GUI
+    {
+        enum class PluginSource
+        {
+            // IMPORTANT: ordinal order is the Plugins dialog Source sort priority.
+            Mine,
+            Subscribed,
+            Local
+        };
+
+        inline std::string to_string(PluginSource source)
+        {
+            switch (source)
+            {
+            case PluginSource::Mine: return "mine";
+            case PluginSource::Subscribed: return "subscribed";
+            case PluginSource::Local: return "local";
+            }
+
+            return "local";
+        }
+    }
+} // namespace Slic3r::GUI

src/slic3r/GUI/PluginStatus.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <string>
+
+namespace Slic3r
+{
+    namespace GUI
+    {
+        enum class PluginStatus
+        {
+            // IMPORTANT: ordinal order is the Plugins dialog Status sort priority.
+            Activated,
+            Error,
+            Inactive,
+            Loading
+        };
+
+        inline std::string to_string(PluginStatus status)
+        {
+            switch (status)
+            {
+            case PluginStatus::Activated: return "Activated";
+            case PluginStatus::Error: return "Error";
+            case PluginStatus::Inactive: return "Inactive";
+            case PluginStatus::Loading: return "Loading";
+            }
+
+            return "Inactive";
+        }
+    }
+} // namespace Slic3r::GUI

src/slic3r/GUI/PluginsDialog.cpp

@@ -25,7 +25,6 @@
 #include <boost/log/trivial.hpp>
 
 #include <algorithm>
-#include <cctype>
 #include <memory>
 #include <mutex>
 #include <vector>
@@ -90,6 +89,7 @@ struct PluginDialogItem
     std::string version;
     std::string installed_version;
     std::string latest_version;
+    std::string sort_version;   // Version shown in the row (installed if installed, else latest); used by the Version sort.
     std::string type_label;
     std::string type_key;
     std::string sharing_token;
@@ -103,7 +103,7 @@ struct PluginDialogItem
     PluginUpdateStatus update_status = PluginUpdateStatus::Normal;
     std::string error_text;
     bool has_error = false;
-    bool loaded    = false;
+    bool is_loaded    = false;
     bool loading   = false;
 
     // Installation and capability flags
@@ -187,27 +187,62 @@ void refresh_plugin_catalog_blocking(bool fetch_cloud)
     }
 }
 
-std::string to_string(PluginSource source)
+std::string to_string(PluginUpdateStatus status);
+nlohmann::json build_context_actions_payload(const PluginAvailableActions& available_actions);
+
+nlohmann::json build_plugin_payload_item(const PluginDialogItem& dialog_item)
 {
-    switch (source) {
-    case PluginSource::Local: return "local";
-    case PluginSource::Mine: return "mine";
-    case PluginSource::Subscribed: return "subscribed";
+    nlohmann::json payload_item;
+    payload_item["plugin_key"]  = dialog_item.plugin_key;
+    payload_item["plugin_id"]   = dialog_item.plugin_id;
+    payload_item["name"]        = dialog_item.display_name;
+    payload_item["description"] = dialog_item.description;
+    payload_item["author"]      = dialog_item.author;
+    payload_item["version"]     = dialog_item.version;
+    payload_item["type"]        = dialog_item.type_label;
+    payload_item["type_key"]    = dialog_item.type_key;
+    payload_item["types"]       = dialog_item.type_labels;
+
+    nlohmann::json caps = nlohmann::json::array();
+    for (const PluginCapabilityView& capability : dialog_item.capabilities) {
+        nlohmann::json c;
+        c["name"]       = capability.name;
+        c["type"]       = capability.type_label;
+        c["type_key"]   = capability.type_key;
+        c["enabled"]    = capability.enabled;
+        c["can_toggle"] = capability.can_toggle;
+        c["can_run"]    = capability.can_run;
+        caps.push_back(std::move(c));
     }
+    payload_item["capabilities"] = std::move(caps);
 
-    return "local";
-}
-
-std::string to_string(PluginStatus status)
-{
-    switch (status) {
-    case PluginStatus::Inactive: return "Inactive";
-    case PluginStatus::Error: return "Error";
-    case PluginStatus::Loading: return "Loading";
-    case PluginStatus::Activated: return "Activated";
+    nlohmann::json changelog = nlohmann::json::array();
+    for (const PluginChangelogView& entry : dialog_item.changelog) {
+        nlohmann::json c;
+        c["version"]      = entry.version;
+        c["changelog"]    = entry.changelog;
+        c["created_time"] = entry.created_time;
+        changelog.push_back(std::move(c));
     }
+    payload_item["changelog"] = std::move(changelog);
 
-    return "Inactive";
+    payload_item["label"]                 = dialog_item.display_name;
+    payload_item["source"]                = to_string(dialog_item.source);
+    payload_item["status"]                = to_string(dialog_item.status);
+    payload_item["error"]                 = dialog_item.error_text;
+    payload_item["update_status"]         = to_string(dialog_item.update_status);
+    payload_item["unauthorized"]          = dialog_item.unauthorized;
+    payload_item["context_actions"]       = build_context_actions_payload(dialog_item.available_actions);
+    payload_item["update_available"]      = dialog_item.update_status == PluginUpdateStatus::UpdateAvailable;
+    payload_item["can_toggle"]            = dialog_item.available_actions.can_toggle;
+    payload_item["has_script_capability"] = dialog_item.has_script_capability;
+    payload_item["can_run_script"]        = dialog_item.can_run_script;
+    payload_item["sharing_token"]         = dialog_item.sharing_token;
+    payload_item["thumbnail_url"]         = dialog_item.thumbnail_url;
+    payload_item["installed"]             = dialog_item.has_local_package;
+    payload_item["installed_version"]     = dialog_item.installed_version;
+    payload_item["latest_version"]        = dialog_item.latest_version;
+    return payload_item;
 }
 
 std::string to_string(PluginUpdateStatus status)
@@ -285,6 +320,9 @@ PluginDialogItem build_plugin_dialog_item(const PluginDescriptor& descriptor)
                                  (descriptor.installed_version.empty() ? descriptor.version : descriptor.installed_version) :
                                  std::string{};
     item.latest_version    = descriptor.latest_available_version();
+    // why: sort by the same version the row displays (GetDisplayVersion in index.js) - installed when
+    //   installed, otherwise latest - so the Version sort matches what the user sees.
+    item.sort_version      = item.installed_version.empty() ? item.latest_version : item.installed_version;
     item.type_label        = descriptor.type_label();
     item.type_key          = plugin_capability_type_to_string(descriptor.primary_capability_type());
     // "types" is the display-only compatibility list. Cloud plugins show the raw labels the
@@ -311,9 +349,9 @@ PluginDialogItem build_plugin_dialog_item(const PluginDescriptor& descriptor)
     item.has_local_package     = descriptor.has_local_package();
     item.unauthorized          = descriptor.is_unauthorized();
     item.has_script_capability = descriptor.has_capability_type(Slic3r::PluginCapabilityType::Script);
-    item.loaded                = loader.is_plugin_loaded(descriptor.plugin_key);
+    item.is_loaded                = loader.is_plugin_loaded(descriptor.plugin_key);
     item.loading               = loader.is_plugin_load_in_progress(descriptor.plugin_key);
-    if (item.loaded) {
+    if (item.is_loaded) {
         for (const auto& cap : loader.get_loaded_plugin_capabilities(descriptor.plugin_key)) {
             if (cap) {
                 item.capabilities.push_back({cap->name, plugin_capability_type_display_name(cap->type),
@@ -342,7 +380,7 @@ PluginDialogItem build_plugin_dialog_item(const PluginDescriptor& descriptor)
         item.status = PluginStatus::Loading;
     else if (item.has_error)
         item.status = PluginStatus::Error;
-    else if (item.loaded)
+    else if (item.is_loaded)
         item.status = PluginStatus::Activated;
     else
         item.status = PluginStatus::Inactive;
@@ -352,7 +390,7 @@ PluginDialogItem build_plugin_dialog_item(const PluginDescriptor& descriptor)
                                                 [](const PluginCapabilityView& capability) {
                                                     return capability.type_key == "script" && capability.enabled;
                                                 });
-    item.can_run_script = descriptor.is_metadata_valid() && !descriptor.has_error() && item.has_script_capability && item.loaded &&
+    item.can_run_script = descriptor.is_metadata_valid() && !descriptor.has_error() && item.has_script_capability && item.is_loaded &&
                           !item.loading && has_enabled_script;
     for (PluginCapabilityView& capability : item.capabilities) {
         capability.can_run = item.can_run_script && capability.type_key == "script" && capability.enabled;
@@ -478,6 +516,8 @@ void PluginsDialog::on_script_message(const nlohmann::json& payload)
         open_plugin_on_cloud(payload.value("sharing_token", ""));
     } else if (command == "open_plugin_hub") {
         open_plugin_hub();
+    } else if (command == "set_plugin_sort") {
+        set_plugin_sort(payload.value("sort_key", ""), payload.value("sort_order", ""));
     } else if (command == "set_plugin_install_action") {
         const std::string action = payload.value("action", "");
         if (action == "explore" || action == "install-local")
@@ -487,92 +527,41 @@ void PluginsDialog::on_script_message(const nlohmann::json& payload)
 
 void PluginsDialog::send_plugins() { call_web_handler(build_plugins_payload()); }
 
+void PluginsDialog::set_plugin_sort(const std::string& sort_key, const std::string& sort_order)
+{
+    m_plugin_sort_key   = plugin_sort_key_from_string(sort_key, m_plugin_sort_key);
+    m_plugin_sort_order = plugin_sort_order_from_string(sort_order, m_plugin_sort_order);
+    send_plugins();
+}
+
 nlohmann::json PluginsDialog::build_plugins_payload() const
 {
     nlohmann::json response;
     response["command"]        = "list_plugins";
     response["install_action"] = s_selected_plugin_install_action;
+    response["sort_key"]       = to_string(m_plugin_sort_key);
+    response["sort_order"]     = to_string(m_plugin_sort_order);
     response["data"]           = nlohmann::json::array();
 
-    auto append_plugin = [&response](const PluginDescriptor& row) {
-        const PluginDialogItem dialog_item = build_plugin_dialog_item(row);
-
-        nlohmann::json payload_item;
-        payload_item["plugin_key"]  = dialog_item.plugin_key;
-        payload_item["plugin_id"]   = dialog_item.plugin_id;
-        payload_item["name"]        = row.name;
-        payload_item["description"] = dialog_item.description;
-        payload_item["author"]      = dialog_item.author;
-        payload_item["version"]     = dialog_item.version;
-        payload_item["installed_version"] = dialog_item.installed_version;
-        payload_item["latest_version"]    = dialog_item.latest_version;
-        payload_item["installed"]         = dialog_item.has_local_package;
-        payload_item["type"]        = dialog_item.type_label;
-        payload_item["type_key"]    = dialog_item.type_key;
-        payload_item["types"]       = dialog_item.type_labels;
-        nlohmann::json caps         = nlohmann::json::array();
-        for (const PluginCapabilityView& capability : dialog_item.capabilities) {
-            nlohmann::json c;
-            c["name"]       = capability.name;
-            c["type"]       = capability.type_label;
-            c["type_key"]   = capability.type_key;
-            c["enabled"]    = capability.enabled;
-            c["can_toggle"] = capability.can_toggle;
-            c["can_run"]    = capability.can_run;
-            caps.push_back(std::move(c));
-        }
-        payload_item["capabilities"] = std::move(caps);
-        nlohmann::json changelog     = nlohmann::json::array();
-        for (const PluginChangelogView& entry : dialog_item.changelog) {
-            nlohmann::json c;
-            c["version"]      = entry.version;
-            c["changelog"]    = entry.changelog;
-            c["created_time"] = entry.created_time;
-            changelog.push_back(std::move(c));
-        }
-        payload_item["changelog"]             = std::move(changelog);
-        payload_item["label"]                 = dialog_item.display_name;
-        payload_item["source"]                = to_string(dialog_item.source);
-        payload_item["status"]                = to_string(dialog_item.status);
-        payload_item["error"]                 = dialog_item.error_text;
-        payload_item["update_status"]         = to_string(dialog_item.update_status);
-        payload_item["unauthorized"]          = dialog_item.unauthorized;
-        payload_item["context_actions"]       = build_context_actions_payload(dialog_item.available_actions);
-        payload_item["update_available"]      = dialog_item.update_status == PluginUpdateStatus::UpdateAvailable;
-        payload_item["can_toggle"]            = dialog_item.available_actions.can_toggle;
-        payload_item["has_script_capability"] = dialog_item.has_script_capability;
-        payload_item["can_run_script"]        = dialog_item.can_run_script;
-        payload_item["sharing_token"]         = dialog_item.sharing_token;
-        payload_item["thumbnail_url"]         = dialog_item.thumbnail_url;
-        response["data"].push_back(std::move(payload_item));
-    };
-
     const auto& catalog = PluginManager::instance().get_catalog();
     const auto valid    = catalog.get_all_plugin_descriptors();
     const auto invalid  = catalog.get_invalid_plugins();
     BOOST_LOG_TRIVIAL(info) << "Prepared " << valid.size() + invalid.size() << " plugin rows for Plugins dialog";
 
+    std::vector<PluginDialogItem> items;
+    items.reserve(valid.size() + invalid.size());
+
     for (const PluginDescriptor& row : valid)
-        append_plugin(row);
+        items.push_back(build_plugin_dialog_item(row));
 
     for (const PluginDescriptor& row : invalid)
-        append_plugin(row);
+        items.push_back(build_plugin_dialog_item(row));
 
-    auto sort_value = [](const nlohmann::json& payload_item, const char* key) { return payload_item.value(key, std::string{}); };
+    // In-place sort
+    sort_plugin_items_for_dialog(items, m_plugin_sort_key, m_plugin_sort_order);
 
-    std::sort(response["data"].begin(), response["data"].end(), [&sort_value](const nlohmann::json& lhs, const nlohmann::json& rhs) {
-        const std::string lhs_source = sort_value(lhs, "source");
-        const std::string rhs_source = sort_value(rhs, "source");
-        if (lhs_source != rhs_source)
-            return lhs_source < rhs_source;
-
-        const std::string lhs_type = sort_value(lhs, "type_key");
-        const std::string rhs_type = sort_value(rhs, "type_key");
-        if (lhs_type != rhs_type)
-            return lhs_type < rhs_type;
-
-        return sort_value(lhs, "name") < sort_value(rhs, "name");
-    });
+    for (const PluginDialogItem& item : items)
+        response["data"].push_back(build_plugin_payload_item(item));
 
     return response;
 }
@@ -1274,7 +1263,7 @@ void PluginsDialog::delete_mine_local_and_cloud_plugin(const std::string& plugin
 
     // delete_mine_local_and_cloud_plugin already updated the in-memory catalog
     // (finalize_cloud_plugin_removal removes the row and, when a local package existed,
-    // re-syncs the cloud list itself), so a UI refresh is sufficient here — an extra
+    // re-syncs the cloud list itself), so a UI refresh is sufficient here - an extra
     // clearing rescan + cloud fetch would be redundant.
     send_plugins();
     show_status(wxString::Format(_L("Deleted \"%s\"."), plugin_name), "success");

src/slic3r/GUI/PluginsDialog.hpp

@@ -2,6 +2,9 @@
 #define slic3r_PluginsDialog_hpp_
 
 #include "Widgets/WebViewHostDialog.hpp"
+#include "PluginSource.hpp"
+#include "PluginStatus.hpp"
+#include "PluginSort.hpp"
 #include "slic3r/plugin/PluginDescriptor.hpp"
 
 #include <exception>
@@ -27,21 +30,6 @@ enum class PluginCapabilityType;
 
 namespace GUI {
 
-enum class PluginSource
-{
-    Local,
-    Mine,
-    Subscribed
-};
-
-enum class PluginStatus
-{
-    Inactive,
-    Error,
-    Loading,
-    Activated
-};
-
 class PluginsDialog : public Slic3r::GUI::WebViewHostDialog
 {
 public:
@@ -63,6 +51,7 @@ private:
     void on_script_message(const nlohmann::json& payload) override;
 
     void send_plugins();
+    void set_plugin_sort(const std::string& sort_key, const std::string& sort_order);
     nlohmann::json build_plugins_payload() const;
 
     bool get_descriptor(const std::string& plugin_key, Slic3r::PluginDescriptor& descriptor) const;
@@ -221,6 +210,8 @@ private:
     }
 
     std::function<void()> m_open_terminal_dlg_fn;
+    PluginSortKey m_plugin_sort_key       = PluginSortKey::None;
+    PluginSortOrder m_plugin_sort_order   = PluginSortOrder::Asc;
 
     // Serializes run_script_plugin. With main-thread execution a plugin's orca.host.ui modal
     // (message/show_dialog) or the result message box pumps a nested event loop, which could