use crate::model::next_sort;
use crate::{ExploreRow, FilterItem, ModsWindow, PageButton, UpdateRow};
use fmm_core::{
catalogue::Catalogue,
explore::{ExploreIndex, FILTERS, FilterMode, Sort, ViewState, group},
locale::Locale,
portal::thumbnail_url,
portal::{PortalMod, PortalModFull},
portal_data::plain_description,
portal_search::SearchPage,
reltime::{parse_timestamp, relative_time},
store::Snapshot,
text::compare_english,
updates::{UpdateCandidate, plan_updates},
version::compare_versions,
};
use slint::{ComponentHandle, Model, ModelRc, VecModel};
use std::{
cell::RefCell,
collections::{HashMap, HashSet},
fs,
path::Path,
rc::Rc,
time::Instant,
};
pub struct CatalogueController {
pub index: Option<ExploreIndex>,
pub view: ViewState,
pub selection: Option<String>,
pub exact_name: Option<String>,
pub updates: Vec<UpdateCandidate>,
pub update_search: String,
pub update_search_open: bool,
/// Column (0 name, 1 local, 2 new, 3 last updated, 4 checked; -1 default) and direction.
pub update_sort: (i32, bool),
pub checked: HashSet<String>,
installed: HashSet<String>,
pub local: Vec<fmm_core::local_mods::LocalMod>,
pub installed_full: HashMap<(String, String), PortalModFull>,
pub game_version: String,
locale: Locale,
pub portal_page: Option<SearchPage>,
pub page: usize,
pub notice: String,
pub loading: bool,
pub full: HashMap<String, PortalModFull>,
pub thumbnails: HashMap<String, slint::Image>,
pub description_images: RefCell<crate::description::Images>,
pub updates_failed: bool,
pub changelog_filter: [usize; 3],
update_mods: Option<Vec<PortalMod>>,
pub progress: HashMap<String, f32>,
pub action_overrides: HashMap<String, i32>,
}
impl CatalogueController {
pub fn new(snapshot: &Snapshot) -> Self {
let locale = fs::read_to_string(
snapshot
.paths
.install_dir
.join("data/core/locale/en/core.cfg"),
)
.map(|s| Locale::parse(&s))
.unwrap_or_default();
Self::from_local(
snapshot
.builtin
.iter()
.chain(&snapshot.mods)
.cloned()
.collect(),
&snapshot.paths.game_version,
locale,
)
}
pub fn from_local(
local: Vec<fmm_core::local_mods::LocalMod>,
game_version: &str,
locale: Locale,
) -> Self {
Self {
installed_full: HashMap::new(),
installed: local.iter().map(|m| m.name.clone()).collect(),
local,
game_version: game_version.into(),
locale,
index: None,
view: ViewState::default(),
selection: None,
exact_name: None,
updates: vec![],
update_search: String::new(),
update_search_open: false,
update_sort: (-1, true),
checked: HashSet::new(),
portal_page: None,
page: 1,
notice: String::new(),
loading: false,
full: HashMap::new(),
thumbnails: HashMap::new(),
description_images: RefCell::default(),
updates_failed: false,
changelog_filter: [0, 0, 3],
update_mods: None,
action_overrides: HashMap::new(),
progress: HashMap::new(),
}
}
pub fn load_metadata(&mut self, store: &fmm_core::metadata::MetadataStore) {
for m in &self.local {
if let Some(full) = store.read(&m.name, &m.version) {
if let Some(url) = thumbnail_url(full.mod_.thumbnail.as_deref())
&& let Ok(path) = store.image_path(&url)
&& path.is_file()
&& let Ok(image) = slint::Image::load_from_path(&path)
{
self.thumbnails.insert(url, image);
}
self.installed_full
.insert((m.name.clone(), m.version.clone()), full.clone());
self.full.entry(m.name.clone()).or_insert(full);
}
}
}
fn installed_row(&self, name: &str, version: &str) -> ExploreRow {
let local = self
.local
.iter()
.find(|m| m.name == name && m.version == version)
.or_else(|| self.local.iter().find(|m| m.name == name));
let full = self
.installed_full
.get(&(name.into(), version.into()))
.or_else(|| self.full.get(name));
let mut metadata = full.map(|f| f.mod_.clone()).unwrap_or_else(|| PortalMod {
name: name.into(),
title: local
.map(|m| m.title.clone())
.unwrap_or_else(|| name.into()),
owner: local.map(|m| m.author.clone()).unwrap_or_default(),
summary: local.map(|m| m.description.clone()).unwrap_or_default(),
..Default::default()
});
metadata.latest_release = None;
metadata.releases = None;
let mut row = self.row(&metadata);
row.thumbnail_url = thumbnail_url(metadata.thumbnail.as_deref())
.unwrap_or_default()
.into();
let thumbnail = self.thumbnails.get(row.thumbnail_url.as_str());
row.thumbnail = thumbnail.cloned().unwrap_or_default();
row.missing = thumbnail.is_none();
row.description = full
.and_then(|f| f.description.as_deref())
.map(plain_description)
.unwrap_or_else(|| metadata.summary.clone())
.into();
row.tags = metadata
.tags
.as_deref()
.unwrap_or_default()
.join(", ")
.into();
row.version = version.into();
if full.is_none() {
row.downloads_count = Default::default();
}
row.title = local
.map(|m| m.title.clone())
.unwrap_or(metadata.title)
.into();
if row.missing
&& let Some(path) = local.and_then(|m| m.thumbnail.as_ref())
&& path.is_file()
&& let Ok(image) = slint::Image::load_from_path(path)
{
row.thumbnail = image;
row.missing = false;
}
if local.is_some_and(|m| m.source == fmm_core::local_mods::ModSource::Builtin) {
row.action = 0;
}
row
}
pub fn publish_rich(&self, app: &ModsWindow) {
let manage = app
.get_rows()
.iter()
.map(|m| {
let mut row = self.installed_row(m.name.as_str(), m.version.as_str());
row.selected = m.selected;
row.checked = m.checked;
row.pending = m.pending;
row.dimmed = m.dimmed;
row.locked = m.locked;
row.warning = m.red;
row.tooltip = m.tooltip;
if m.placeholder {
row.name = m.name;
row.title = m.title;
row.version = m.version;
row.installed = false;
row.action = 0;
}
row.placeholder = m.placeholder;
row.downloading = m.download || m.failed;
row.failed = m.failed;
row.fraction = m.fraction;
row.progress_label = m.progress_label;
row
})
.collect::<Vec<_>>();
app.set_manage_rich_detail(manage.iter().find(|r| r.selected).cloned().unwrap_or_else(
|| ExploreRow {
missing: true,
..Default::default()
},
));
set_rich_model(app.get_manage_rich_rows(), manage, |m| {
app.set_manage_rich_rows(m)
});
let updates = self
.visible_updates()
.into_iter()
.map(|m| {
let mut row = self.installed_row(&m.name, &m.local_version);
row.action = 2;
row.version = m.new_version.clone().into();
row.update_badge = format!("{} → {}", m.local_version, m.new_version).into();
row.selected = app.get_updates_picked().as_str() == m.name;
row.checked = self.checked.contains(&m.name);
row
})
.collect::<Vec<_>>();
set_rich_model(app.get_updates_rich_rows(), updates, |m| {
app.set_updates_rich_rows(m)
});
}
pub fn set_catalogue(&mut self, index: Option<ExploreIndex>) {
if self.update_mods.is_some() {
self.index = index;
return;
}
self.updates = index
.as_ref()
.map(|i| {
// S5 intentionally uses latest_release only, even if a fixture supplies full releases.
let mut latest: Vec<_> = i
.mods
.iter()
.filter(|m| self.installed.contains(&m.name))
.cloned()
.collect();
for m in &mut latest {
m.releases = None;
}
plan_updates(&self.local, &latest, &self.game_version).updates
})
.unwrap_or_default();
self.checked = self.updates.iter().map(|m| m.name.clone()).collect();
self.index = index;
}
pub fn set_updates(&mut self, mods: &[PortalMod]) {
let old: HashSet<_> = self.updates.iter().map(|m| m.name.clone()).collect();
self.updates = plan_updates(&self.local, mods, &self.game_version).updates;
self.checked
.retain(|n| self.updates.iter().any(|m| &m.name == n));
for m in &self.updates {
if !old.contains(&m.name) {
self.checked.insert(m.name.clone());
}
}
self.updates_failed = false;
self.update_mods = Some(mods.to_vec());
}
pub fn selected_updates(&self) -> Vec<String> {
self.updates
.iter()
.filter(|m| self.checked.contains(&m.name))
.map(|m| m.name.clone())
.collect()
}
pub fn rescan(&mut self, snapshot: &Snapshot) {
self.local = snapshot
.builtin
.iter()
.chain(&snapshot.mods)
.cloned()
.collect();
self.installed = self.local.iter().map(|m| m.name.clone()).collect();
let mut mods = self.update_mods.clone().unwrap_or_else(|| {
self.index
.as_ref()
.map(|i| i.mods.clone())
.unwrap_or_default()
});
for full in self.full.values() {
mods.retain(|m| m.name != full.mod_.name);
mods.push(full.mod_.clone());
}
self.set_updates(&mods);
}
pub fn capture_action(&mut self, name: &str, action: i32) {
self.action_overrides
.insert(name.into(), if action == 4 { 2 } else { action });
if action == 3 {
self.updates.retain(|m| m.name != name);
self.checked.remove(name);
}
if action == 1 {
self.installed.remove(name);
self.local.retain(|m| m.name != name);
} else {
self.installed.insert(name.into());
for m in self.local.iter_mut().filter(|m| m.name == name) {
m.source = if action == 4 {
fmm_core::local_mods::ModSource::Folder
} else {
fmm_core::local_mods::ModSource::Zip
};
}
}
if self.updates.iter().any(|m| m.name == name) {
self.checked.insert(name.into());
}
}
pub fn installed_names(&self) -> Vec<String> {
self.local
.iter()
.filter(|m| m.source != fmm_core::local_mods::ModSource::Builtin)
.map(|m| m.name.clone())
.collect::<HashSet<_>>()
.into_iter()
.collect()
}
pub fn selected_mod(&self) -> Option<&PortalMod> {
let name = self.selection.as_deref()?;
self.full
.get(name)
.map(|f| &f.mod_)
.or_else(|| {
self.portal_page
.as_ref()
.and_then(|p| p.mods.iter().find(|m| m.name == name))
})
.or_else(|| {
self.index
.as_ref()
.and_then(|i| i.mods.iter().find(|m| m.name == name))
})
}
pub fn focus_dependency(&mut self, name: &str) {
self.view = ViewState::default();
self.view.filters.fill(FilterMode::Off);
self.view.search = name.into();
self.exact_name = Some(name.into());
self.selection = Some(name.into());
self.page = 1;
self.portal_page = None;
self.loading = false;
self.notice.clear();
}
pub fn visible_mods(&self) -> Vec<&PortalMod> {
if let Some(name) = &self.exact_name {
return self
.full
.get(name)
.map(|f| &f.mod_)
.or_else(|| {
self.index
.as_ref()
.and_then(|i| i.mods.iter().find(|m| &m.name == name))
})
.into_iter()
.collect();
}
if let Some(p) = &self.portal_page {
return p.mods.iter().collect();
}
self.index
.as_ref()
.map(|i| {
i.query(&self.view)
.rows
.into_iter()
.skip((self.page - 1) * 20)
.take(20)
.map(|n| &i.mods[n])
.collect()
})
.unwrap_or_default()
}
pub fn publish_changelog(&self, app: &ModsWindow) {
let selection = if app.get_current_tab() == 2 && !app.get_updates_picked().is_empty() {
Some(app.get_updates_picked().to_string())
} else {
self.selection.clone()
};
let log = selection
.as_ref()
.and_then(|n| self.full.get(n))
.and_then(|f| f.changelog.as_deref())
.map(fmm_core::changelog::parse)
.unwrap_or_default();
let versions = log.versions();
let version = versions
.get(self.changelog_filter[0])
.map(String::as_str)
.unwrap_or_default();
let subversions = log.subversions(version);
let sub = subversions
.get(self.changelog_filter[1])
.map(String::as_str)
.unwrap_or("All");
let category = crate::model::CHANGELOG_CATEGORIES
.get(self.changelog_filter[2])
.copied()
.unwrap_or("All");
let (text, date) = log.display(version, sub, category);
app.set_portal_changelog_text(text.into());
app.set_portal_changelog_date(date.into());
app.set_portal_changelog_versions(ModelRc::new(VecModel::from(
versions.into_iter().map(Into::into).collect::<Vec<_>>(),
)));
app.set_portal_changelog_subversions(ModelRc::new(VecModel::from(
subversions.into_iter().map(Into::into).collect::<Vec<_>>(),
)));
app.set_portal_changelog_version(self.changelog_filter[0] as i32);
app.set_portal_changelog_subversion(self.changelog_filter[1] as i32);
app.set_portal_changelog_category(self.changelog_filter[2] as i32);
}
fn label(&self, section: &str, key: &str, fallback: &str) -> String {
self.locale.get(section, key).unwrap_or(fallback).into()
}
pub fn visible_updates(&self) -> Vec<&UpdateCandidate> {
let q = self.update_search.to_lowercase();
let mut rows: Vec<_> = self
.updates
.iter()
.filter(|m| m.title.to_lowercase().contains(&q) || m.name.to_lowercase().contains(&q))
.collect();
let (column, ascending) = self.update_sort;
if matches!(column, 0..=4) {
rows.sort_by(|a, b| {
let by_name = || {
compare_english(&a.title, &b.title, true)
.then_with(|| compare_english(&a.name, &b.name, false))
};
if column == 4 {
let order = self
.checked
.contains(&b.name)
.cmp(&self.checked.contains(&a.name));
return (if ascending { order } else { order.reverse() }).then_with(by_name);
}
let order = match column {
1 => compare_versions(&a.local_version, &b.local_version),
2 => compare_versions(&a.new_version, &b.new_version),
3 => released(a).cmp(&released(b)),
_ => compare_english(&a.title, &b.title, true),
}
.then_with(by_name);
if ascending { order } else { order.reverse() }
});
}
rows
}
pub fn sort_updates(&mut self, column: i32) {
if matches!(column, 0..=4) {
self.update_sort = next_sort(self.update_sort.0, self.update_sort.1, column);
}
}
pub fn toggle_update(&mut self, name: &str) {
if self.updates.iter().any(|m| m.name == name) && !self.checked.remove(name) {
self.checked.insert(name.into());
}
}
pub fn toggle_updates(&mut self) {
let names: Vec<_> = self
.visible_updates()
.iter()
.map(|m| m.name.clone())
.collect();
let all = names.iter().all(|n| self.checked.contains(n));
for n in names {
if all {
self.checked.remove(&n);
} else {
self.checked.insert(n);
}
}
}
pub fn update_message(&self) -> String {
if self.updates_failed || !self.has_update_data() {
self.label(
"gui-update-mods",
"check-for-updates-failed",
"Unable to check for updates",
)
} else if self.updates.is_empty() {
self.label(
"gui-update-mods",
"all-mods-up-to-date",
"All mods are up to date",
)
} else {
String::new()
}
}
pub fn has_update_data(&self) -> bool {
self.index.is_some() || self.update_mods.is_some()
}
pub fn select(&mut self, name: &str) {
if self
.portal_page
.as_ref()
.is_some_and(|p| p.mods.iter().any(|m| m.name == name))
|| self
.index
.as_ref()
.is_some_and(|i| i.mods.iter().any(|m| m.name == name))
|| self.full.contains_key(name)
|| self.updates.iter().any(|m| m.name == name)
{
self.selection = Some(name.into());
}
}
fn row(&self, m: &fmm_core::portal::PortalMod) -> ExploreRow {
let full = self.full.get(&m.name);
let metadata = full.map(|f| &f.mod_).unwrap_or(m);
let release = full
.and_then(|f| fmm_core::updates::newest_compatible_release(&f.mod_, &self.game_version))
.or_else(|| {
self.index
.as_ref()
.and_then(|i| i.mods.iter().find(|p| p.name == m.name))
.and_then(|m| {
fmm_core::updates::newest_compatible_release(m, &self.game_version)
})
});
let release = release.or(m.latest_release.as_ref());
let updated = m
.latest_release
.as_ref()
.map(|r| r.released_at.as_str())
.filter(|s| !s.is_empty())
.or_else(|| full.and_then(|f| f.updated_at.as_deref()))
.or_else(|| release.map(|r| r.released_at.as_str()))
.unwrap_or_default();
let url = thumbnail_url(metadata.thumbnail.as_deref()).unwrap_or_default();
let thumbnail = self.thumbnails.get(&url);
ExploreRow {
failed: false,
placeholder: false,
progress_label: Default::default(),
checked: false,
pending: false,
dimmed: false,
locked: false,
warning: false,
tooltip: Default::default(),
downloading: self.progress.contains_key(&m.name),
fraction: self.progress.get(&m.name).copied().unwrap_or_default(),
action: self
.action_overrides
.get(&m.name)
.copied()
.unwrap_or_else(|| {
crate::operations::action(
&m.name,
&self.local,
self.updates.iter().any(|u| u.name == m.name)
|| release.is_some_and(|r| {
r.info_json.factorio_version
== fmm_core::version::game_line(&self.game_version)
&& self
.local
.iter()
.filter(|l| l.name == m.name)
.all(|l| compare_versions(&r.version, &l.version).is_gt())
}),
)
}),
name: m.name.clone().into(),
title: m.title.clone().into(),
owner: m.owner.clone().into(),
summary: m.summary.clone().into(),
downloads_count: m.downloads_count.to_string().into(),
version: release
.map(|r| r.version.clone())
.unwrap_or_default()
.into(),
released_at: release
.map(|r| r.released_at.clone())
.unwrap_or_default()
.into(),
category: m.category.as_deref().unwrap_or("no-category").into(),
category_label: plain_label(&self.label(
"gui-explore-mods-filter-name",
m.category.as_deref().unwrap_or("no-category"),
m.category.as_deref().unwrap_or("no-category"),
))
.into(),
updated: date_part(updated).into(),
installed: self.installed.contains(&m.name),
thumbnail_url: url.into(),
thumbnail: thumbnail.cloned().unwrap_or_default(),
missing: thumbnail.is_none(),
description: full
.and_then(|f| f.description.as_deref())
.map(plain_description)
.unwrap_or_else(|| m.summary.clone())
.into(),
tags: metadata
.tags
.as_deref()
.unwrap_or_default()
.join(", ")
.into(),
has_changelog: full
.and_then(|f| f.changelog.as_deref())
.is_some_and(|s| !fmm_core::changelog::parse(s).releases.is_empty()),
update_badge: self
.updates
.iter()
.find(|u| u.name == m.name)
.map(|u| format!("{} → {}", u.local_version, u.new_version))
.or_else(|| {
self.local
.iter()
.filter(|l| l.name == m.name)
.max_by(|a, b| compare_versions(&a.version, &b.version))
.map(|l| format!("Installed {}", l.version))
})
.unwrap_or_default()
.into(),
selected: self.selection.as_deref() == Some(&m.name),
}
}
pub fn publish(&self, app: &ModsWindow) {
self.publish_rich(app);
let result = if !self.loading && self.portal_page.is_none() {
self.index.as_ref().map(|i| i.query(&self.view))
} else {
None
};
let found = if self.exact_name.is_some() {
self.visible_mods().len()
} else {
self.portal_page
.as_ref()
.map(|p| p.found)
.unwrap_or_else(|| result.as_ref().map(|r| r.rows.len()).unwrap_or_default())
};
app.set_explore_loading(self.loading);
if !self.loading {
let rows: Vec<_> = self
.visible_mods()
.into_iter()
.map(|m| self.row(m))
.collect();
let current = app.get_explore_rows();
// Selection, detail and thumbnail updates keep the model and its virtualized rows alive.
if let Some(model) = current.as_any().downcast_ref::<VecModel<ExploreRow>>()
&& model.row_count() == rows.len()
&& model.iter().zip(&rows).all(|(a, b)| a.name == b.name)
{
for (i, row) in rows.into_iter().enumerate() {
if model.row_data(i).as_ref() != Some(&row) {
model.set_row_data(i, row);
}
}
} else {
app.set_explore_rows(ModelRc::new(VecModel::from(rows)));
}
app.set_explore_count(found as i32);
}
// -1: the source can't count this filter (the bulk catalogue has no tags), so no count is shown.
let counts: [i32; 28] = if let Some(page) = &self.portal_page {
page.counts.map(|c| c as i32)
} else if let Some(r) = &result {
std::array::from_fn(|i| {
if r.known & (1 << i) != 0 {
r.counts[i] as i32
} else {
-1
}
})
} else {
std::array::from_fn(|i| {
if self.loading {
app.get_explore_filters().row_data(i).map_or(0, |f| f.count)
} else {
0
}
})
};
let pages = self
.portal_page
.as_ref()
.map(|p| p.pages)
.unwrap_or_else(|| found.div_ceil(20).max(1));
if !self.loading {
app.set_explore_pages(ModelRc::new(VecModel::from(page_buttons(self.page, pages))));
app.set_explore_page_number(self.page as i32);
app.set_explore_notice(self.notice.clone().into());
}
app.set_explore_filters(ModelRc::new(VecModel::from(
FILTERS
.iter()
.enumerate()
.map(|(i, id)| FilterItem {
id: (*id).into(),
label: plain_label(&self.label("gui-explore-mods-filter-name", id, id)).into(),
description: self
.label("gui-explore-mods-filter-description", id, "")
.into(),
group: group(i) as i32,
count: counts[i],
included: self.view.filters[i] == FilterMode::Include,
excluded: self.view.filters[i] == FilterMode::Exclude,
})
.collect::<Vec<_>>(),
)));
let detail = self
.selected_mod()
.map(|m| self.row(m))
.unwrap_or_else(|| ExploreRow {
missing: true,
..Default::default()
});
app.set_explore_detail(detail);
app.set_explore_search_text(self.view.search.clone().into());
app.set_explore_sort(match self.view.sort {
Sort::Relevance => 0,
Sort::Downloads => 1,
Sort::Updated => 2,
Sort::Trending => 3,
});
app.set_explore_error(
if self.index.is_none() && self.portal_page.is_none() && self.visible_mods().is_empty()
{
self.label(
"gui-explore-mods",
"unable-to-search",
"Unable to search the mod portal",
)
} else {
String::new()
}
.into(),
);
app.set_explore_found(
self.label("gui-explore-mods", "total-mods-count", "Found __1__ mods")
.replace("__1__", &app.get_explore_count().to_string())
.into(),
);
app.set_explore_group_names(ModelRc::new(VecModel::from(
[
("expansion", "Expansion"),
("categories", "Categories"),
("tags", "Tags"),
]
.map(|(k, f)| self.label("gui-explore-mods", k, f).into())
.to_vec(),
)));
app.set_explore_sort_names(ModelRc::new(VecModel::from(
[
("relevancy", "Relevance"),
("most_downloads", "Downloads"),
("last_updated_at", "Recently updated"),
("trending", "Trending"),
]
.map(|(k, f)| {
self.label("gui-explore-mods-sort-attribute-name", k, f)
.into()
})
.to_vec(),
)));
app.set_explore_sort_label(self.label("gui-explore-mods", "sort-by", "Sort by").into());
app.set_explore_exclude_tip(
self.label(
"gui-explore-mods",
"exclude-filter",
"Exclude from search results",
)
.into(),
);
let visible = self.visible_updates();
let now = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map_or(0, |d| d.as_secs() as i64);
app.set_updates_all_checked(
!visible.is_empty() && visible.iter().all(|m| self.checked.contains(&m.name)),
);
app.set_updates_mixed(
visible.iter().any(|m| self.checked.contains(&m.name))
&& !app.get_updates_all_checked(),
);
app.set_updates_rows(ModelRc::new(VecModel::from(
visible
.into_iter()
.map(|m| UpdateRow {
downloading: self.progress.contains_key(&m.name),
fraction: self.progress.get(&m.name).copied().unwrap_or_default(),
name: m.name.clone().into(),
title: m.title.clone().into(),
local_version: m.local_version.clone().into(),
new_version: m.new_version.clone().into(),
updated: released(m)
.map_or_else(String::new, |t| relative_time(now, t))
.into(),
checked: self.checked.contains(&m.name),
})
.collect::<Vec<_>>(),
)));
app.set_updates_count(self.updates.len() as i32);
app.set_updates_selected_count(self.selected_updates().len() as i32);
app.set_updates_message(self.update_message().into());
app.set_updates_failed(!self.has_update_data() || self.updates_failed);
app.set_updates_search_text(self.update_search.clone().into());
app.set_updates_search_open(self.update_search_open);
app.set_updates_headers(ModelRc::new(VecModel::from(
[
("name-column-header", "Name"),
("local-version-column-header", "Local version"),
("new-version-column-header", "New version"),
("", "Latest update"),
]
.map(|(k, f)| {
if k.is_empty() {
f.to_string()
} else {
self.label("gui-update-mods", k, f)
}
.into()
})
.to_vec(),
)));
let action = self.label("gui-update-mods", "update-selected", "Update selected");
app.set_updates_action_label(
match self.selected_updates().len() {
0 => action,
n => format!("{action} ({n})"),
}
.into(),
);
app.set_updates_sort_column(self.update_sort.0);
app.set_updates_sort_ascending(self.update_sort.1);
self.publish_changelog(app);
let update_name = app.get_updates_picked();
app.set_updates_detail_action(
self.updates
.iter()
.find(|m| m.name == update_name.as_str())
.map_or(0, |_| 2),
);
let detail = if app.get_current_tab() == 2 && !update_name.is_empty() {
self.full
.get(update_name.as_str())
.map(|f| &f.mod_)
.or_else(|| {
self.index
.as_ref()
.and_then(|i| i.mods.iter().find(|m| m.name == update_name.as_str()))
})
} else {
self.selected_mod()
};
app.set_portal_detail(
detail
.map(|m| {
let full = self.full.get(&m.name);
let mut detail = crate::bindings::portal_detail(m, full, &self.thumbnails);
self.description_images.borrow_mut().project(&detail.blocks);
crate::description::reflow(
&detail.blocks,
app.global::<crate::DescriptionImages>().get_pane_width(),
);
detail.dependencies =
crate::bindings::portal_dependencies(full, &self.local, &self.game_version);
detail
})
.unwrap_or_default(),
);
}
}
pub fn load_index(path: &Path, game_version: &str) -> Option<ExploreIndex> {
let start = Instant::now();
let catalogue = match Catalogue::load(path) {
Ok(c) => c,
Err(e) => {
eprintln!("Catalogue {} unavailable: {e}", path.display());
return None;
}
};
eprintln!(
"Catalogue: {} mods loaded in {:?}",
catalogue.results.len(),
start.elapsed()
);
let start = Instant::now();
let index = ExploreIndex::new(catalogue.results, game_version);
eprintln!("Catalogue index: {:?}", start.elapsed());
Some(index)
}
pub fn page_buttons(current: usize, pages: usize) -> Vec<PageButton> {
if pages <= 1 {
return vec![];
}
let mut numbers = vec![1, 2, pages.saturating_sub(1), pages];
numbers.extend(current.saturating_sub(1).max(1)..=(current + 1).min(pages));
numbers.sort_unstable();
numbers.dedup();
let button = |text: String, page: usize| PageButton {
text: text.into(),
page: page as i32,
current: page == current,
};
let mut out = vec![button("«".into(), current.saturating_sub(1))];
let mut previous = 0;
for page in numbers.into_iter().filter(|p| *p > 0 && *p <= pages) {
if previous > 0 && page > previous + 1 {
out.push(button("…".into(), 0));
}
out.push(button(page.to_string(), page));
previous = page;
}
out.push(button(
"»".into(),
if current < pages { current + 1 } else { 0 },
));
out
}
pub fn bind(app: &ModsWindow, controller: CatalogueController) -> Rc<RefCell<CatalogueController>> {
let c = Rc::new(RefCell::new(controller));
macro_rules! bind {
($callback:ident, |$state:ident $(, $arg:ident)*| $body:expr) => {{
let c = c.clone(); let weak = app.as_weak();
app.$callback(move |$($arg),*| {
let mut $state = c.borrow_mut(); $body;
if let Some(app) = weak.upgrade() { $state.publish(&app); }
});
}};
}
bind!(on_explore_search, |s, text| {
s.exact_name = None;
s.view.search = text.to_string();
});
bind!(
on_explore_sort_changed,
|s, index| s.view.sort = match index {
1 => Sort::Downloads,
2 => Sort::Updated,
3 => Sort::Trending,
_ => Sort::Relevance,
}
);
bind!(on_explore_filter, |s, id, exclude| s
.view
.toggle_filter(id.as_str(), exclude));
bind!(on_explore_selected, |s, name| s.select(name.as_str()));
bind!(on_updates_search, |s, text| s.update_search =
text.to_string());
bind!(on_updates_toggle_search, |s| {
s.update_search_open = !s.update_search_open;
if !s.update_search_open {
s.update_search.clear();
}
});
bind!(on_updates_sort, |s, column| s.sort_updates(column));
bind!(on_updates_toggled, |s, name| s.toggle_update(name.as_str()));
bind!(on_updates_toggle_all, |s| s.toggle_updates());
bind!(on_explore_page, |s, page| s.page = (page as usize).max(1));
bind!(on_portal_changelog_filter, |s, kind, index| {
if let Some(value) = s.changelog_filter.get_mut(kind as usize) {
*value = (index as usize).min(10000);
}
if kind == 0 {
s.changelog_filter[1] = 0;
}
});
let weak = app.as_weak();
app.on_portal_open_changelog(move || {
if let Some(app) = weak.upgrade()
&& app.get_portal_detail().has_changelog
{
app.set_show_portal_changelog(true);
}
});
let rich = c.clone();
let weak = app.as_weak();
app.on_rich_refresh(move || {
if let Some(app) = weak.upgrade() {
rich.borrow().publish_rich(&app);
}
});
c.borrow().publish(app);
c
}
/// When the update's release went up, in epoch seconds.
fn released(update: &UpdateCandidate) -> Option<i64> {
parse_timestamp(&update.release.released_at)
}
/// `2024-10-17T09:30:00.123000Z` → `2024-10-17`.
fn date_part(timestamp: &str) -> String {
timestamp
.split(['T', ' '])
.next()
.unwrap_or_default()
.into()
}
/// Drops locale rich-text tags such as `[space-age]` (the view draws the expansion icon itself).
fn plain_label(label: &str) -> String {
let mut out = String::new();
let mut depth = 0;
for c in label.chars() {
match c {
'[' => depth += 1,
']' if depth > 0 => depth -= 1,
_ if depth == 0 => out.push(c),
_ => {}
}
}
out.split_whitespace().collect::<Vec<_>>().join(" ")
}
fn set_rich_model(
current: ModelRc<ExploreRow>,
rows: Vec<ExploreRow>,
set: impl FnOnce(ModelRc<ExploreRow>),
) {
if let Some(model) = current.as_any().downcast_ref::<VecModel<ExploreRow>>()
&& model.row_count() == rows.len()
&& model.iter().zip(&rows).all(|(a, b)| a.name == b.name)
{
for (i, row) in rows.into_iter().enumerate() {
if model.row_data(i).as_ref() != Some(&row) {
model.set_row_data(i, row);
}
}
} else {
set(ModelRc::new(VecModel::from(rows)));
}
}
#[cfg(test)]
mod label_tests {
use super::{date_part, plain_label};
#[test]
fn keeps_only_the_date_of_a_release_timestamp() {
assert_eq!(date_part("2024-10-17T09:30:00.123000Z"), "2024-10-17");
assert_eq!(date_part("2024-10-17 09:30:00"), "2024-10-17");
assert_eq!(date_part("2024-10-17"), "2024-10-17");
assert_eq!(date_part(""), "");
}
#[test]
fn strips_rich_text_tags_and_extra_spaces() {
assert_eq!(plain_label("Space Age [space-age]"), "Space Age");
assert_eq!(plain_label("[img=item/x] Name"), "Name");
assert_eq!(plain_label("Plain label"), "Plain label");
assert_eq!(plain_label("Open [bracket"), "Open");
}
}