diff --git a/resources/web/dialog/PluginsDialog/index.html b/resources/web/dialog/PluginsDialog/index.html index 5b647f3d3b..853d1a8464 100644 --- a/resources/web/dialog/PluginsDialog/index.html +++ b/resources/web/dialog/PluginsDialog/index.html @@ -5,6 +5,7 @@ Plugins + @@ -14,6 +15,7 @@ +
@@ -43,9 +45,14 @@
Activate - Name - Plugin Version - Status + Name + Plugin Version + Source + Status
diff --git a/resources/web/dialog/PluginsDialog/index.js b/resources/web/dialog/PluginsDialog/index.js index 7310201a92..b2e7b235ea 100644 --- a/resources/web/dialog/PluginsDialog/index.js +++ b/resources/web/dialog/PluginsDialog/index.js @@ -214,6 +214,10 @@ function HandleStudio(value) { if (payload.command === "list_plugins") { SetSelectedInstallAction(payload.install_action, false); + if (typeof NormalizePluginSort === "function") { + pluginSort = NormalizePluginSort(payload.sort_key, payload.sort_order); + RenderSortHeaders(); + } ApplyPlugins(payload.data || []); } else if (payload.command === "status_message") { ShowStatusMessage(String(payload.message || ""), String(payload.level || "info")); @@ -329,6 +333,7 @@ function RenderPlugins() { row.appendChild(CheckCell(row, plugin)); row.appendChild(LabelCell(plugin, isExpanded, capabilities.length)); row.appendChild(VersionCell(plugin)); + row.appendChild(SourceCell(plugin)); row.appendChild(StatusCell(plugin)); block.appendChild(row); @@ -523,11 +528,24 @@ function LabelCell(plugin, isExpanded = false, capabilityCount = 0) { nameWrap.appendChild(countBadge); } labelCell.appendChild(nameWrap); - labelCell.appendChild(SourceBadge(plugin.source)); return labelCell; } +function SourceCell(plugin) { + const cell = document.createElement("span"); + const normalized = String(plugin.source || "").toLowerCase(); + const variant = (normalized === "mine" || normalized === "subscribed") ? normalized : "local"; + cell.className = `source-cell source-${variant}`; + + const sourceLabel = document.createElement("span"); + sourceLabel.className = "source-label"; + sourceLabel.textContent = SourceLabel(plugin.source); + cell.appendChild(sourceLabel); + + return cell; +} + function RenderCapabilityTree(plugin, capabilities) { const tree = document.createElement("div"); tree.className = "capabilities-tree"; @@ -566,6 +584,11 @@ function RenderCapabilityRow(plugin, capability, isLast) { typeCell.textContent = String(capability?.type || "-"); row.appendChild(typeCell); + // why: empty placeholder for the new Source column so the run-action cell stays under Status. + const sourceSpacer = document.createElement("span"); + sourceSpacer.className = "capability-source-cell"; + row.appendChild(sourceSpacer); + const actionsCell = document.createElement("span"); actionsCell.className = "capability-actions-cell"; const capabilityName = String(capability?.name || ""); diff --git a/resources/web/dialog/PluginsDialog/plugin-sort.css b/resources/web/dialog/PluginsDialog/plugin-sort.css new file mode 100644 index 0000000000..31c5ec627c --- /dev/null +++ b/resources/web/dialog/PluginsDialog/plugin-sort.css @@ -0,0 +1,42 @@ +/* why: sort affordance lives on the list column headers, not a toolbar dropdown. */ + +.hdr .sort-th { + display: flex; + align-items: center; + gap: 6px; + cursor: pointer; + user-select: none; +} + +.hdr .sort-th .sort-tri { + width: 0; + height: 0; + flex: none; + border-left: 4px solid transparent; + border-right: 4px solid transparent; + display: none; +} + +/* faint up-triangle hint on hover, only while the column is not the active sort */ +.hdr .sort-th:hover .sort-tri { + display: block; + border-bottom: 5px solid var(--muted); +} + +/* active column wins over the hover hint (same specificity, declared later) */ +.hdr .sort-th[data-sort="asc"] .sort-tri { + display: block; + border-bottom: 5px solid var(--text); + border-top: 0; +} + +.hdr .sort-th[data-sort="desc"] .sort-tri { + display: block; + border-top: 5px solid var(--text); + border-bottom: 0; +} + +.hdr .sort-th[data-sort="asc"], +.hdr .sort-th[data-sort="desc"] { + color: var(--text); +} diff --git a/resources/web/dialog/PluginsDialog/plugin-sort.js b/resources/web/dialog/PluginsDialog/plugin-sort.js new file mode 100644 index 0000000000..a3020f9c01 --- /dev/null +++ b/resources/web/dialog/PluginsDialog/plugin-sort.js @@ -0,0 +1,67 @@ +// why: C++ owns ordering; this file only sends and reflects sort state. + +const DEFAULT_PLUGIN_SORT = { key: "none", order: "asc" }; +// note: SORT_FIELDS are the clickable columns. "none" is the baseline/cleared state, not a field - +// it is special-cased in NormalizePluginSort and produced by CyclePluginSort's third click. +const SORT_FIELDS = new Set(["status", "name", "source", "version"]); +let pluginSort = { ...DEFAULT_PLUGIN_SORT }; + +// why: C++ returns canonical sort state; guard stale or malformed values before reflecting them. +function NormalizePluginSort(sortKey, sortOrder) { + const key = String(sortKey || ""); + return { + key: key === "none" ? "none" : (SORT_FIELDS.has(key) ? key : DEFAULT_PLUGIN_SORT.key), + order: sortOrder === "desc" ? "desc" : DEFAULT_PLUGIN_SORT.order, + }; +} + +function RequestPluginSort(sortKey, sortOrder) { + pluginSort = NormalizePluginSort(sortKey, sortOrder); + RenderSortHeaders(); + + if (typeof SendMessage === "function") + SendMessage("set_plugin_sort", { + sort_key: pluginSort.key, + sort_order: pluginSort.order, + }); +} + +// why: one click per column cycles asc -> desc -> clear; setting any column clears the previous +// one for free because C++ (and pluginSort) only ever hold a single key. +function CyclePluginSort(field) { + if (!SORT_FIELDS.has(field)) + return; + if (pluginSort.key !== field) + RequestPluginSort(field, "asc"); + else if (pluginSort.order === "asc") + RequestPluginSort(field, "desc"); + else + RequestPluginSort("none", "asc"); // third click: back to baseline +} + +// why: paints the sort indicator for headers +// e.g., when user clicks triangle to change sort order, or change to sort by a new different field +function RenderSortHeaders() { + document.querySelectorAll(".hdr .sort-th").forEach((th) => { + // "" | "asc" | "desc" - renders the triangle via plugin-sort.css [data-sort=...]. + th.dataset.sort = th.dataset.sortField === pluginSort.key ? pluginSort.order : ""; + }); +} + +function InitSortHeaders() { + document.querySelectorAll(".hdr .sort-th").forEach((th) => { + th.addEventListener("click", () => CyclePluginSort(th.dataset.sortField)); + // note: role="button" cells need Enter/Space to match the old dropdown's keyboard access. + th.addEventListener("keydown", (event) => { + if (event.key === "Enter" || event.key === " ") { + event.preventDefault(); + CyclePluginSort(th.dataset.sortField); + } + }); + }); + RenderSortHeaders(); // paint the initial state (baseline = no triangle) +} + +// why: guarded so the module can be loaded in headless syntax checks. +if (typeof document !== "undefined") + document.addEventListener("DOMContentLoaded", InitSortHeaders); diff --git a/resources/web/dialog/PluginsDialog/styles.css b/resources/web/dialog/PluginsDialog/styles.css index ce9d4f3a3d..ef1c3b4d92 100644 --- a/resources/web/dialog/PluginsDialog/styles.css +++ b/resources/web/dialog/PluginsDialog/styles.css @@ -187,7 +187,27 @@ body { } .plugin-cols { - grid-template-columns: 70px minmax(0, 2.8fr) minmax(120px, 0.9fr) minmax(140px, 1fr); + grid-template-columns: 70px minmax(0, 2.4fr) minmax(110px, 0.85fr) minmax(96px, 0.7fr) minmax(130px, 0.95fr); +} + +/* Source is its own (sortable) column, shown as colored text (mirrors .status-cell), not a chip. */ +.source-cell { + display: flex; + align-items: center; +} + +.source-cell.source-mine { + color: var(--plugin-source-mine-text); + font-weight: 600; +} + +.source-cell.source-subscribed { + color: var(--plugin-source-subscribed-text); + font-weight: 600; +} + +.source-cell.source-local { + color: var(--plugin-source-neutral-text); } /* Center the "Activate" header over the centered checkbox in each row. */ @@ -835,11 +855,6 @@ body { white-space: nowrap; } -/* In a list row, sit at the right edge of the Name column (the name fills the rest). */ -.label-cell .plugin-source-badge { - margin-right: 4px; -} - .plugin-source-badge.source-local { background: var(--plugin-source-neutral-bg); color: var(--plugin-source-neutral-text); diff --git a/src/slic3r/CMakeLists.txt b/src/slic3r/CMakeLists.txt index 16636517d7..647af33174 100644 --- a/src/slic3r/CMakeLists.txt +++ b/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 diff --git a/src/slic3r/GUI/PluginSort.hpp b/src/slic3r/GUI/PluginSort.hpp new file mode 100644 index 0000000000..d0a45cbd05 --- /dev/null +++ b/src/slic3r/GUI/PluginSort.hpp @@ -0,0 +1,210 @@ +#pragma once + +#include "PluginSource.hpp" +#include "PluginStatus.hpp" + +#include "libslic3r/Semver.hpp" + +#include +#include +#include +#include +#include + +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(lhs[li]); + const unsigned char rc = static_cast(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(lhs[li]))) + ++li; + while (ri < rhs.size() && std::isdigit(static_cast(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 + 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(lhs.source) - static_cast(rhs.source); cmp != 0) + return cmp; + if (const int cmp = static_cast(lhs.status) - static_cast(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 + 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(lhs.status) - static_cast(rhs.status); + case PluginSortKey::Name: + return compare_ascii_case_insensitive_natural(lhs.display_name, rhs.display_name); + case PluginSortKey::Source: + return static_cast(lhs.source) - static_cast(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 + void sort_plugin_items_for_dialog(std::vector& 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 diff --git a/src/slic3r/GUI/PluginSource.hpp b/src/slic3r/GUI/PluginSource.hpp new file mode 100644 index 0000000000..ee1464c8df --- /dev/null +++ b/src/slic3r/GUI/PluginSource.hpp @@ -0,0 +1,29 @@ +#pragma once + +#include + +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 diff --git a/src/slic3r/GUI/PluginStatus.hpp b/src/slic3r/GUI/PluginStatus.hpp new file mode 100644 index 0000000000..477e9d99fe --- /dev/null +++ b/src/slic3r/GUI/PluginStatus.hpp @@ -0,0 +1,31 @@ +#pragma once + +#include + +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 diff --git a/src/slic3r/GUI/PluginsDialog.cpp b/src/slic3r/GUI/PluginsDialog.cpp index 9b0b253698..070bc36a14 100644 --- a/src/slic3r/GUI/PluginsDialog.cpp +++ b/src/slic3r/GUI/PluginsDialog.cpp @@ -25,7 +25,6 @@ #include #include -#include #include #include #include @@ -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 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"); diff --git a/src/slic3r/GUI/PluginsDialog.hpp b/src/slic3r/GUI/PluginsDialog.hpp index f7e657ecdf..55885262a5 100644 --- a/src/slic3r/GUI/PluginsDialog.hpp +++ b/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 @@ -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 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 diff --git a/tests/slic3rutils/CMakeLists.txt b/tests/slic3rutils/CMakeLists.txt index 626ae128e1..1e62c1a6ba 100644 --- a/tests/slic3rutils/CMakeLists.txt +++ b/tests/slic3rutils/CMakeLists.txt @@ -4,6 +4,7 @@ add_executable(${_TEST_NAME}_tests test_plugin_host_api.cpp test_plugin_capability_identifier.cpp test_plugin_install.cpp + test_plugin_sort.cpp ) if (MSVC) diff --git a/tests/slic3rutils/test_plugin_sort.cpp b/tests/slic3rutils/test_plugin_sort.cpp new file mode 100644 index 0000000000..58db799dd8 --- /dev/null +++ b/tests/slic3rutils/test_plugin_sort.cpp @@ -0,0 +1,189 @@ +#include + +#include + +#include +#include + +using Slic3r::GUI::compare_ascii_case_insensitive_natural; +using Slic3r::GUI::PluginSortKey; +using Slic3r::GUI::PluginSortOrder; +using Slic3r::GUI::PluginSource; +using Slic3r::GUI::PluginStatus; +using Slic3r::GUI::plugin_sort_key_from_string; +using Slic3r::GUI::plugin_sort_order_from_string; +using Slic3r::GUI::sort_plugin_items_for_dialog; + +namespace { + +struct SortFixtureItem +{ + std::string plugin_key; + PluginSource source; + PluginStatus status; + std::string type_key; + std::string display_name; + std::string sort_version; +}; + +std::vector keys(const std::vector& items) +{ + std::vector result; + result.reserve(items.size()); + for (const SortFixtureItem& item : items) + result.push_back(item.plugin_key); + return result; +} + +} // namespace + +TEST_CASE("plugin dialog status sort uses requested priority and base-order ties", "[plugin][sort]") +{ + std::vector items = { + {"local_inactive", PluginSource::Local, PluginStatus::Inactive, "script", "Local Inactive"}, + {"mine_error", PluginSource::Mine, PluginStatus::Error, "script", "Mine Error"}, + {"mine_activated", PluginSource::Mine, PluginStatus::Activated, "script", "Mine Activated"}, + {"local_activated", PluginSource::Local, PluginStatus::Activated, "script", "Local Activated"}, + {"subscribed_loading", PluginSource::Subscribed, PluginStatus::Loading, "script", "Subscribed Loading"}, + }; + + sort_plugin_items_for_dialog(items, PluginSortKey::Status, PluginSortOrder::Asc); + + // why: local_activated and mine_activated tie on Status, so base order breaks the tie by name + // (case-insensitive) - "Local Activated" before "Mine Activated". + const std::vector expected = { + "local_activated", + "mine_activated", + "mine_error", + "local_inactive", + "subscribed_loading", + }; + CHECK(keys(items) == expected); + + sort_plugin_items_for_dialog(items, PluginSortKey::Status, PluginSortOrder::Desc); + + // why: Desc reverses the status ordinal, but the Activated tie still resolves by ascending + // base order (name: "Local Activated" before "Mine Activated") - direction only flips the key. + const std::vector desc_expected = { + "subscribed_loading", + "local_inactive", + "mine_error", + "local_activated", + "mine_activated", + }; + CHECK(keys(items) == desc_expected); +} + +TEST_CASE("plugin dialog source sort uses enum priority", "[plugin][sort]") +{ + std::vector items = { + {"local", PluginSource::Local, PluginStatus::Activated, "script", "Local"}, + {"mine", PluginSource::Mine, PluginStatus::Activated, "script", "Mine"}, + {"subscribed", PluginSource::Subscribed, PluginStatus::Activated, "script", "Subscribed"}, + }; + + sort_plugin_items_for_dialog(items, PluginSortKey::Source, PluginSortOrder::Asc); + const std::vector asc_expected = {"mine", "subscribed", "local"}; + CHECK(keys(items) == asc_expected); + + sort_plugin_items_for_dialog(items, PluginSortKey::Source, PluginSortOrder::Desc); + const std::vector desc_expected = {"local", "subscribed", "mine"}; + CHECK(keys(items) == desc_expected); +} + +TEST_CASE("plugin dialog version sort is semver-aware with base-order ties", "[plugin][sort]") +{ + std::vector items = { + {"v_1_2_0", PluginSource::Local, PluginStatus::Activated, "script", "B", "1.2.0"}, + {"v_1_10_0", PluginSource::Local, PluginStatus::Activated, "script", "A", "1.10.0"}, + {"v_0_9_3", PluginSource::Local, PluginStatus::Activated, "script", "C", "0.9.3"}, + }; + + sort_plugin_items_for_dialog(items, PluginSortKey::Version, PluginSortOrder::Asc); + // why: semver numeric compare - 1.10.0 > 1.2.0 (not lexical "1.10" < "1.2"), so ascending is + // 0.9.3 < 1.2.0 < 1.10.0. + const std::vector asc_expected = {"v_0_9_3", "v_1_2_0", "v_1_10_0"}; + CHECK(keys(items) == asc_expected); + + sort_plugin_items_for_dialog(items, PluginSortKey::Version, PluginSortOrder::Desc); + const std::vector desc_expected = {"v_1_10_0", "v_1_2_0", "v_0_9_3"}; + CHECK(keys(items) == desc_expected); +} + +TEST_CASE("plugin dialog name sort is case-insensitive and numeric-aware", "[plugin][sort]") +{ + std::vector items = { + {"rig10", PluginSource::Local, PluginStatus::Activated, "script", "Rig 10"}, + {"ada_lower", PluginSource::Local, PluginStatus::Activated, "script", "ada"}, + {"rig2", PluginSource::Local, PluginStatus::Activated, "script", "Rig 2"}, + {"ada_upper", PluginSource::Local, PluginStatus::Activated, "script", "Ada"}, + }; + + sort_plugin_items_for_dialog(items, PluginSortKey::Name, PluginSortOrder::Asc); + + // why: "Ada"/"ada" tie on the case-insensitive name (primary AND base name level), so the tie + // falls through source/status/type to plugin_key: "ada_lower" before "ada_upper". + const std::vector expected = {"ada_lower", "ada_upper", "rig2", "rig10"}; + CHECK(keys(items) == expected); + + sort_plugin_items_for_dialog(items, PluginSortKey::Name, PluginSortOrder::Desc); + + // why: names reverse ("Rig 10" before "Rig 2"), but "Ada"/"ada" tie on the case-insensitive + // key and keep ascending base order, which resolves by plugin_key ("ada_lower" < "ada_upper"). + const std::vector desc_expected = {"rig10", "rig2", "ada_lower", "ada_upper"}; + CHECK(keys(items) == desc_expected); +} + +TEST_CASE("natural compare handles digits, case, prefixes and leading zeros", "[plugin][sort]") +{ + // numeric runs compare by value, not lexically + CHECK(compare_ascii_case_insensitive_natural("item2", "item10") < 0); + CHECK(compare_ascii_case_insensitive_natural("item10", "item2") > 0); + CHECK(compare_ascii_case_insensitive_natural("2", "10") < 0); + + // case is ignored on the primary comparison + CHECK(compare_ascii_case_insensitive_natural("Camera", "camera") == 0); + + // a prefix is less than the longer string it prefixes + CHECK(compare_ascii_case_insensitive_natural("app", "apple") < 0); + CHECK(compare_ascii_case_insensitive_natural("apple", "app") > 0); + + // equal numeric value: fewer leading zeros wins the tie + CHECK(compare_ascii_case_insensitive_natural("1", "01") < 0); + CHECK(compare_ascii_case_insensitive_natural("01", "1") > 0); + + // reflexivity and empty-string boundaries + CHECK(compare_ascii_case_insensitive_natural("plugin", "plugin") == 0); + CHECK(compare_ascii_case_insensitive_natural("", "") == 0); + CHECK(compare_ascii_case_insensitive_natural("", "a") < 0); +} + +TEST_CASE("plugin dialog None sort key falls to ascending base order in both directions", "[plugin][sort]") +{ + std::vector items = { + {"z_mine", PluginSource::Mine, PluginStatus::Activated, "script", "Zebra"}, + {"a_local", PluginSource::Local, PluginStatus::Activated, "script", "Apple"}, + {"m_sub", PluginSource::Subscribed, PluginStatus::Error, "script", "Mango"}, + }; + + // why: no primary key -> pure name-first base order (Apple < Mango < Zebra). A source-first + // baseline would instead give {z_mine, m_sub, a_local}, so this pins the name-first order. + const std::vector base_expected = {"a_local", "m_sub", "z_mine"}; + + sort_plugin_items_for_dialog(items, PluginSortKey::None, PluginSortOrder::Asc); + CHECK(keys(items) == base_expected); + + // why: None has no direction - Desc must not reverse the baseline. + sort_plugin_items_for_dialog(items, PluginSortKey::None, PluginSortOrder::Desc); + CHECK(keys(items) == base_expected); +} + +TEST_CASE("plugin dialog sort request parsing keeps previous state on invalid values", "[plugin][sort]") +{ + CHECK(plugin_sort_key_from_string("source", PluginSortKey::Status) == PluginSortKey::Source); + CHECK(plugin_sort_key_from_string("none", PluginSortKey::Status) == PluginSortKey::None); + CHECK(plugin_sort_key_from_string("missing", PluginSortKey::Name) == PluginSortKey::Name); + + CHECK(plugin_sort_order_from_string("desc", PluginSortOrder::Asc) == PluginSortOrder::Desc); + CHECK(plugin_sort_order_from_string("down", PluginSortOrder::Asc) == PluginSortOrder::Asc); +}