use crate::{
DependencyItem, InfoRow, ManageRow, ModsWindow,
controller::{Controller, ManageEffects},
model::ManageModel,
};
use fmm_core::{
Result,
mod_list::ModList,
store::{Snapshot, apply_changes, is_factorio_running},
};
use slint::{ComponentHandle, Image, ModelRc, VecModel};
use std::{cell::RefCell, path::Path, rc::Rc};
pub struct StoreEffects;
impl ManageEffects for StoreEffects {
fn running(&mut self) -> bool {
is_factorio_running()
}
fn apply(
&mut self,
snapshot: &Snapshot,
pending: &crate::model::Pending,
pins: &crate::model::Pins,
) -> Result<ModList> {
apply_changes(snapshot, pending, pins)
}
fn quit(&mut self) {
let _ = slint::quit_event_loop();
}
}
pub fn publish(app: &ModsWindow, model: ManageModel, error: &str) {
app.set_sort_column(model.view.sort_column);
app.set_sort_ascending(model.view.ascending);
app.set_search_open(model.view.search_open);
app.set_search_text(model.view.search_text.clone().into());
app.set_show_changelog(model.view.show_changelog);
app.set_has_changelog(!model.changelog.releases.is_empty());
let versions = model.changelog.versions();
let version = versions
.get(model.view.changelog_version)
.map(String::as_str)
.unwrap_or_default();
let subversions = model.changelog.subversions(version);
let subversion = subversions
.get(model.view.changelog_subversion)
.map(String::as_str)
.unwrap_or("All");
let category = crate::model::CHANGELOG_CATEGORIES
.get(model.view.changelog_category)
.copied()
.unwrap_or("All");
let (text, date) = model.changelog.display(version, subversion, category);
app.set_changelog_text(if model.changelog.releases.is_empty() {
"No changelog".into()
} else {
text.into()
});
app.set_changelog_date(date.into());
app.set_changelog_version(model.view.changelog_version as i32);
app.set_changelog_subversion(model.view.changelog_subversion as i32);
app.set_changelog_category(model.view.changelog_category as i32);
app.set_changelog_versions(ModelRc::new(VecModel::from(
versions.into_iter().map(Into::into).collect::<Vec<_>>(),
)));
app.set_changelog_subversions(ModelRc::new(VecModel::from(
subversions.into_iter().map(Into::into).collect::<Vec<_>>(),
)));
app.set_mixed(model.rows.iter().any(|r| r.checked) && !model.rows.iter().all(|r| r.checked));
app.set_all_checked(!model.rows.is_empty() && model.rows.iter().all(|r| r.checked));
let rows: Vec<_> = model
.rows
.into_iter()
.map(|r| ManageRow {
name: r.name.into(),
title: r.title.into(),
version: r.version.into(),
checked: r.checked,
locked: r.locked,
dimmed: r.dimmed,
pending: r.pending,
selected: r.selected,
red: r.red,
tooltip: r.tooltip.into(),
download: r.download,
failed: r.failed,
placeholder: r.placeholder,
fraction: r.fraction,
progress_label: r.progress_label.into(),
})
.collect();
app.set_selected_name(
rows.iter()
.find(|r| r.selected)
.map(|r| r.name.clone())
.unwrap_or_default(),
);
app.set_manage_remove_enabled(
rows.iter()
.any(|r| r.selected && !fmm_core::local_mods::BUILTIN_ORDER.contains(&r.name.as_str())),
);
app.set_rows(ModelRc::new(VecModel::from(rows)));
app.set_detail_title(model.title.into());
app.set_description(model.description.into());
let info: Vec<_> = model
.info
.into_iter()
.map(|r| InfoRow {
key: r.key.into(),
value: r.value.into(),
link: r.link,
dependency: r.dependency,
red: r.red,
})
.collect();
app.set_info(ModelRc::new(VecModel::from(info)));
let deps: Vec<_> = model
.dependencies
.into_iter()
.map(|r| DependencyItem {
installed: r.installed,
name: r.name.into(),
text: r.text.into(),
optional: r.optional,
incompatible: r.incompatible,
red: r.red,
tooltip: r.tooltip.into(),
})
.collect();
app.set_dependencies(ModelRc::new(VecModel::from(deps)));
app.set_pending_count(model.pending_count);
app.set_manage_issue(model.issue.into());
app.set_manage_install_missing(model.install_missing);
app.set_manage_versions(ModelRc::new(VecModel::from(
model
.versions
.into_iter()
.map(Into::into)
.collect::<Vec<_>>(),
)));
app.set_manage_version_choice(model.version_choice);
app.set_manage_notice(model.notice.into());
app.set_missing(model.missing);
if !model.thumbnail.is_empty() {
match Image::load_from_path(Path::new(&model.thumbnail)) {
Ok(image) => app.set_thumbnail(image),
Err(_) => app.set_missing(true),
}
}
app.set_error(error.into());
app.invoke_rich_refresh();
}
pub fn bind_manage<E: ManageEffects + 'static>(
app: &ModsWindow,
snapshot: Snapshot,
effects: Rc<RefCell<E>>,
) -> Rc<RefCell<Controller>> {
let controller = Rc::new(RefCell::new(Controller::new(snapshot)));
macro_rules! bind {
($callback:ident, |$c:ident, $e:ident, $arg:ident| $body:expr) => {{
let controller = controller.clone();
let effects = effects.clone();
let weak = app.as_weak();
app.$callback(move |$arg| {
if weak.upgrade().is_some_and(|app| app.get_batch_busy()) {
return;
}
let mut $c = controller.borrow_mut();
let mut $e = effects.borrow_mut();
$body;
if let Some(app) = weak.upgrade() {
publish(&app, $c.model(), &$c.error);
}
});
}};
}
bind!(on_selected, |c, _e, name| c.select(name.as_str()));
let c = controller.clone();
let weak = app.as_weak();
app.on_manage_focus(move |name| {
let mut c = c.borrow_mut();
if c.focus_installed(name.as_str())
&& let Some(app) = weak.upgrade()
{
app.set_current_tab(0);
app.set_manage_view(0);
app.set_show_portal_changelog(false);
publish(&app, c.model(), &c.error);
let index = c
.model()
.rows
.iter()
.position(|r| r.name == name.as_str())
.unwrap_or(0);
app.set_manage_focus_row(index as i32);
app.set_manage_focus_tick(app.get_manage_focus_tick() + 1);
}
});
bind!(on_manage_pin, |c, _e, index| c.pin(index));
bind!(on_toggled, |c, _e, name| c.toggle(name.as_str()));
bind!(on_sort, |c, _e, column| c.sort(column));
bind!(on_search, |c, _e, text| c.search(text.as_str()));
let c = controller.clone();
let weak = app.as_weak();
app.on_toggle_search(move || {
let mut c = c.borrow_mut();
c.toggle_search();
if let Some(app) = weak.upgrade() {
publish(&app, c.model(), &c.error);
}
});
let c = controller.clone();
let weak = app.as_weak();
app.on_open_changelog(move || {
let mut c = c.borrow_mut();
c.open_changelog();
if let Some(app) = weak.upgrade() {
publish(&app, c.model(), &c.error);
}
});
let c = controller.clone();
let weak = app.as_weak();
app.on_changelog_filter(move |kind, index| {
let mut c = c.borrow_mut();
c.changelog_filter(kind, index);
if let Some(app) = weak.upgrade() {
publish(&app, c.model(), &c.error);
}
});
// The no-argument callbacks use the same state and never hold a strong UI handle.
let c = controller.clone();
let weak = app.as_weak();
app.on_toggle_all(move || {
if weak.upgrade().is_some_and(|app| app.get_batch_busy()) {
return;
}
let mut c = c.borrow_mut();
c.toggle_all();
if let Some(app) = weak.upgrade() {
publish(&app, c.model(), &c.error);
}
});
let c = controller.clone();
let e = effects.clone();
let weak = app.as_weak();
app.on_confirm(move || {
if weak.upgrade().is_some_and(|app| app.get_batch_busy()) {
return;
}
let mut c = c.borrow_mut();
c.confirm(&mut *e.borrow_mut());
if let Some(app) = weak.upgrade() {
if !c.error.is_empty() {
crate::audio::cannot(&app);
}
publish(&app, c.model(), &c.error);
}
});
let c = controller.clone();
let e = effects.clone();
let weak = app.as_weak();
app.on_save(move || {
let Some(app) = weak.upgrade() else { return };
if app.get_batch_busy() {
return;
}
let mut c = c.borrow_mut();
if !c.save(&mut *e.borrow_mut()) {
crate::audio::cannot(&app);
}
publish(&app, c.model(), &c.error);
});
let c = controller.clone();
let weak = app.as_weak();
app.on_undo(move || {
if weak.upgrade().is_some_and(|app| app.get_batch_busy()) {
return;
}
let mut c = c.borrow_mut();
c.undo();
if let Some(app) = weak.upgrade() {
publish(&app, c.model(), &c.error);
}
});
let c = controller.clone();
let weak = app.as_weak();
app.on_request_close(move || {
if weak.upgrade().is_some_and(|app| app.get_batch_busy()) {
return;
}
let mut c = c.borrow_mut();
if c.view.show_changelog {
c.view.show_changelog = false;
if let Some(app) = weak.upgrade() {
publish(&app, c.model(), &c.error);
}
} else {
c.back(&mut *effects.borrow_mut());
}
});
publish(app, controller.borrow().model(), &controller.borrow().error);
controller
}
thread_local! {
static DOCUMENTS: RefCell<std::collections::VecDeque<(String, ModelRc<crate::DescriptionBlock>)>> = const { RefCell::new(std::collections::VecDeque::new()) };
}
pub fn portal_detail(
m: &fmm_core::portal::PortalMod,
full: Option<&fmm_core::portal::PortalModFull>,
thumbnails: &std::collections::HashMap<String, Image>,
) -> crate::PortalDetail {
use fmm_core::{
markdown::{self, Kind},
portal,
};
let description = full
.and_then(|f| f.description.as_deref())
.unwrap_or(&m.summary);
let blocks = DOCUMENTS.with_borrow_mut(|cache| {
if let Some((_, blocks)) = cache.iter().find(|(source, _)| source == description) {
return blocks.clone();
}
let blocks = markdown::parse(description)
.into_iter()
.map(|b| {
let (kind, level) = match b.kind {
Kind::Paragraph => (0, 0),
Kind::Heading(n) => (1, i32::from(n)),
Kind::ListItem => (2, 0),
Kind::Code => (3, 0),
Kind::Rule => (4, 0),
Kind::Image => (5, 0),
};
let text = if kind == 3 {
slint::StyledText::from_plain_text(&b.text)
} else {
// Use a different outer delimiter so a bold word at either edge of a
// heading cannot merge with its heading-weight delimiter.
let text = if kind == 1 {
markdown::heading_inline(&b.text)
} else {
b.text.clone()
};
slint::StyledText::from_markdown(&text).unwrap_or_else(|error| {
eprintln!("Description inline fallback: {error}");
slint::StyledText::from_plain_text(
&fmm_core::portal_data::plain_description(&b.text),
)
})
};
crate::DescriptionBlock {
kind,
level,
depth: b.depth as i32,
text,
marker: b.marker.into(),
row_height: 28.0,
images: ModelRc::new(VecModel::from(
b.images
.into_iter()
.map(|item| crate::DescriptionImage {
alt: item.alt.into(),
url: item.url.into(),
link: item.link.into(),
playhead: ModelRc::new(VecModel::from(vec![0])),
..Default::default()
})
.collect::<Vec<_>>(),
)),
}
})
.collect::<Vec<_>>();
let model = ModelRc::new(VecModel::from(blocks));
cache.push_back((description.into(), model.clone()));
if cache.len() > 16 {
cache.pop_front();
}
model
});
let info = |key: &str, value: String, url: String| crate::DetailInfo {
key: key.into(),
value: value.into(),
url: if markdown::browser_url(&url) {
url.into()
} else {
Default::default()
},
};
let mut rows = vec![info(
"Owner",
m.owner.clone(),
format!(
"https://mods.factorio.com/user/{}",
portal::encode_component(&m.owner)
),
)];
let mut versions: Vec<_> = m
.releases
.as_deref()
.unwrap_or_default()
.iter()
.map(|r| r.info_json.factorio_version.as_str())
.filter(|s| !s.is_empty())
.collect();
versions.sort_by(|a, b| fmm_core::version::compare_versions(a, b));
versions.dedup();
let supported = match (versions.first(), versions.last()) {
(Some(a), Some(b)) if a != b => format!("{a} - {b}"),
(Some(a), _) => (*a).into(),
_ => m
.latest_release
.as_ref()
.map(|r| r.info_json.factorio_version.clone())
.unwrap_or_default(),
};
let latest = m
.releases
.as_deref()
.unwrap_or_default()
.iter()
.max_by(|a, b| fmm_core::version::compare_versions(&a.version, &b.version))
.or(m.latest_release.as_ref());
let license = full.and_then(|f| f.license.as_ref());
rows.push(info(
"Mod portal",
format!(
"https://mods.factorio.com/mod/{}",
portal::encode_component(&m.name)
),
format!(
"https://mods.factorio.com/mod/{}",
portal::encode_component(&m.name)
),
));
rows.extend([
info(
"Created",
full.and_then(|f| f.created_at.as_deref())
.unwrap_or_default()
.split('T')
.next()
.unwrap_or_default()
.into(),
String::new(),
),
info(
"Source",
full.and_then(|f| f.source_url.clone())
.filter(|s| !s.is_empty())
.unwrap_or_else(|| "N/A".into()),
full.and_then(|f| f.source_url.clone()).unwrap_or_default(),
),
info(
"Latest version",
latest.map(|r| r.version.clone()).unwrap_or_default(),
String::new(),
),
info(
"Homepage",
full.and_then(|f| f.homepage.clone())
.filter(|s| !s.is_empty())
.unwrap_or_else(|| "N/A".into()),
full.and_then(|f| f.homepage.clone()).unwrap_or_default(),
),
info("Factorio version", supported, String::new()),
info(
"License",
license
.and_then(|l| l.get("title").or_else(|| l.get("name")))
.and_then(|s| s.as_str())
.unwrap_or("N/A")
.into(),
license
.and_then(|l| l.get("url"))
.and_then(|s| s.as_str())
.unwrap_or_default()
.into(),
),
info(
"Downloaded by",
format!("{} users", m.downloads_count),
String::new(),
),
]);
let thumbnail =
portal::thumbnail_url(m.thumbnail.as_deref()).and_then(|url| thumbnails.get(&url));
crate::PortalDetail {
name: m.name.clone().into(),
title: m.title.clone().into(),
blocks,
gallery: ModelRc::new(VecModel::from(
full.map(|f| {
f.images
.iter()
.filter(|img| {
markdown::image_url(&img.thumbnail) && markdown::image_url(&img.url)
})
.map(|img| crate::GalleryImage {
thumbnail: thumbnails.get(&img.thumbnail).cloned().unwrap_or_default(),
source: thumbnails.get(&img.url).cloned().unwrap_or_default(),
missing: !thumbnails.contains_key(&img.thumbnail),
url: img.url.clone().into(),
})
.collect::<Vec<_>>()
})
.unwrap_or_default(),
)),
info: ModelRc::new(VecModel::from(rows)),
dependencies: Default::default(),
thumbnail: thumbnail.cloned().unwrap_or_default(),
missing: thumbnail.is_none(),
tags: m.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()),
}
}
pub fn portal_dependencies(
full: Option<&fmm_core::portal::PortalModFull>,
local: &[fmm_core::local_mods::LocalMod],
game: &str,
) -> ModelRc<crate::PortalDependency> {
use fmm_core::{
local_mods::ModSource,
updates::newest_compatible_release,
version::{self, DependencyKind},
};
let rows = full
.and_then(|f| newest_compatible_release(&f.mod_, game))
.and_then(|r| r.info_json.dependencies.as_deref())
.unwrap_or_default()
.iter()
.filter_map(|s| version::parse_dependency(s))
.map(|dep| {
let installed = local
.iter()
.filter(|m| m.name == dep.name)
.max_by(|a, b| version::compare_versions(&a.version, &b.version));
let mut text = dep.name.clone();
if let Some(cmp) = dep.comparator {
text.push_str(&format!(
" {cmp} {}",
dep.version.as_deref().unwrap_or_default()
));
}
text.push_str(match dep.kind {
DependencyKind::Optional => " (optional)",
DependencyKind::HiddenOptional => " (hidden optional)",
DependencyKind::Incompatible => " (incompatible)",
_ => "",
});
if let Some(m) = installed {
text.push_str(&format!(
" — {} {}",
if m.source == ModSource::Builtin {
"built-in"
} else {
"installed"
},
m.version
));
if !version::satisfies(&m.version, &dep) {
text.push_str(" (version mismatch)");
}
} else {
text.push_str(" — not installed");
}
crate::PortalDependency {
installed: installed.is_some(),
name: dep.name.clone().into(),
text: text.into(),
optional: dep.kind == DependencyKind::Optional,
incompatible: dep.kind == DependencyKind::Incompatible,
hidden: dep.kind == DependencyKind::HiddenOptional,
red: dep.kind == DependencyKind::Incompatible
|| (matches!(
dep.kind,
DependencyKind::Required | DependencyKind::NoLoadOrder
) && installed.is_none_or(|m| !version::satisfies(&m.version, &dep))),
}
})
.collect::<Vec<_>>();
ModelRc::new(VecModel::from(rows))
}
pub fn bind_detail_links(app: &ModsWindow, opener: impl Fn(&str) + 'static) {
app.on_detail_open_url(move |url| {
if fmm_core::markdown::browser_url(&url) {
opener(&url);
}
});
}
pub fn open_browser(url: &str) {
if !fmm_core::markdown::browser_url(url) {
return;
}
#[cfg(windows)]
{
#[link(name = "shell32")]
unsafe extern "system" {
fn ShellExecuteW(
window: isize,
operation: *const u16,
file: *const u16,
parameters: *const u16,
directory: *const u16,
show: i32,
) -> isize;
}
let operation: Vec<_> = "open".encode_utf16().chain(Some(0)).collect();
let file: Vec<_> = url.encode_utf16().chain(Some(0)).collect();
// SAFETY: null-terminated UTF-16 strings live through this synchronous Win32 call.
let result = unsafe {
ShellExecuteW(
0,
operation.as_ptr(),
file.as_ptr(),
std::ptr::null(),
std::ptr::null(),
1,
)
};
if result <= 32 {
eprintln!("Open in browser failed: {result}");
}
}
#[cfg(target_os = "linux")]
{
let url = url.to_owned();
std::thread::spawn(move || {
if let Err(e) = fmm_core::linux::open_browser(&url) {
eprintln!("Open in browser failed: {e}");
}
});
}
#[cfg(target_os = "macos")]
{
let url = url.to_owned();
std::thread::spawn(move || {
if let Err(e) = fmm_core::macos::open_browser(&url) {
eprintln!("Open in browser failed: {e}");
}
});
}
}
/// The software renderer samples textures with nearest-neighbour regardless of image-rendering.
/// Rasterize only the visible viewport, with premultiplied bilinear filtering, for headless captures.
/// Memory stays bounded by the window even when an original is zoomed to 8x.
pub fn lightbox_raster(
source: Image,
zoom: f32,
pan_x: f32,
pan_y: f32,
width: f32,
height: f32,
) -> Image {
let Some(input) = source.to_rgba8() else {
return source;
};
if zoom <= 0.0 || input.width() == 0 || input.height() == 0 {
return Image::default();
}
let (w, h) = (
width.max(1.0).round() as u32,
height.max(1.0).round() as u32,
);
let mut output = slint::SharedPixelBuffer::<slint::Rgba8Pixel>::new(w, h);
let (sw, sh) = (input.width(), input.height());
let left = (width - sw as f32 * zoom) / 2.0 + pan_x;
let top = (height - sh as f32 * zoom) / 2.0 + pan_y;
for y in 0..h {
for x in 0..w {
let sx = (x as f32 + 0.5 - left) / zoom;
let sy = (y as f32 + 0.5 - top) / zoom;
if sx < 0.0 || sy < 0.0 || sx >= sw as f32 || sy >= sh as f32 {
continue;
}
let sx = (sx - 0.5).clamp(0.0, sw as f32 - 1.0);
let sy = (sy - 0.5).clamp(0.0, sh as f32 - 1.0);
let (x0, y0) = (sx.floor() as u32, sy.floor() as u32);
let (fx, fy) = (sx.fract(), sy.fract());
let mut channels = [0.0f32; 4];
for (px, py, weight) in [
(x0, y0, (1.0 - fx) * (1.0 - fy)),
((x0 + 1).min(sw - 1), y0, fx * (1.0 - fy)),
(x0, (y0 + 1).min(sh - 1), (1.0 - fx) * fy),
((x0 + 1).min(sw - 1), (y0 + 1).min(sh - 1), fx * fy),
] {
let p = input.as_slice()[(py * sw + px) as usize];
let alpha = p.a as f32 * weight;
channels[0] += p.r as f32 * alpha;
channels[1] += p.g as f32 * alpha;
channels[2] += p.b as f32 * alpha;
channels[3] += alpha;
}
if channels[3] > 0.0 {
output.make_mut_slice()[(y * w + x) as usize] = slint::Rgba8Pixel::new(
(channels[0] / channels[3]).round() as u8,
(channels[1] / channels[3]).round() as u8,
(channels[2] / channels[3]).round() as u8,
channels[3].round() as u8,
);
}
}
}
Image::from_rgba8(output)
}
pub fn bind_software_lightbox(app: &ModsWindow) {
app.on_lightbox_raster(lightbox_raster);
app.set_lightbox_software(true);
}