// The release build is a GUI program: no console window next to the app (debug builds keep one).
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
use fmm_core::install::TRASH_NAME;
mod audio;
mod bindings;
mod capture;
mod catalogue;
mod chrome;
mod controller;
mod description;
mod live;
mod model;
mod operations;
mod settings;
mod watch;
use fmm_core::{Result, store::load_snapshot_with_data};
use slint::ComponentHandle;
use std::{
cell::RefCell,
fs,
path::{Path, PathBuf},
rc::Rc,
};
slint::include_modules!();
#[derive(Default)]
struct Options {
view_mode: Option<i32>,
screenshot: Option<PathBuf>,
fixture: Option<PathBuf>,
size: Option<(u32, u32)>,
/// Capture-only state for the live (no fixture) capture: selected mod, pending `name=0|1` list,
/// dependency line whose tooltip is forced visible, row drawn pressed.
select: Option<String>,
pending: Vec<(String, bool)>,
force_tip: Option<i32>,
pressed_row: Option<i32>,
/// Row index whose missing-dependency tooltip is forced visible.
force_row_tip: Option<i32>,
hover_row: Option<i32>,
hover_checkbox: Option<i32>,
sort: Option<(i32, bool)>,
search: Option<String>,
changelog: Option<bool>,
tab: Option<i32>,
catalogue: Option<PathBuf>,
explore_search: Option<String>,
explore_sort: Option<fmm_core::explore::Sort>,
explore_filters: Vec<(String, fmm_core::explore::FilterMode)>,
explore_select: Option<String>,
force_filter_tip: Option<i32>,
force_exclude_tip: Option<i32>,
updates_select: Option<String>,
updates_search: Option<String>,
updates_sort: Option<(i32, bool)>,
force_search_tip: Option<bool>,
filter_end: Option<bool>,
dropdown_open: Option<bool>,
dropdown_hover: Option<i32>,
dropdown_pressed: Option<i32>,
portal_html: Option<PathBuf>,
portal_full: Option<PathBuf>,
portal_updates: Option<PathBuf>,
portal_changelog: Option<bool>,
explore_page: Option<usize>,
detail_gallery: Option<i32>,
detail_scroll: Option<f32>,
lightbox: Option<usize>,
lightbox_zoom: Option<f32>,
explore_loading: Option<bool>,
explore_action: Option<i32>,
download_progress: Vec<(String, f32)>,
confirm_plan: Option<PathBuf>,
remove_confirm: Option<String>,
results_banner: Option<String>,
pointer: Option<(f32, f32)>,
pointer_press: bool,
wheel: Option<(f32, f32, f32, f32)>,
pin_dropdown_open: Option<bool>,
settings_open: Option<bool>,
onboarding_open: Option<bool>,
onboarding_folders: Option<PathBuf>,
dependency: Option<String>,
description_images: Option<PathBuf>,
description_frame: Option<i32>,
description_loading: bool,
}
fn filter_index(id: &str) -> Result<i32> {
fmm_core::explore::FILTERS
.iter()
.position(|f| *f == id)
.map(|i| i as i32)
.ok_or_else(|| format!("Unknown filter: {id}").into())
}
fn parse_args(args: impl Iterator<Item = String>) -> Result<Options> {
let mut args = args;
let mut options = Options::default();
while let Some(arg) = args.next() {
let value = args
.next()
.ok_or("Expected --screenshot out.png --size WIDTHxHEIGHT [--fixture data.json]")?;
match arg.as_str() {
"--description-images" => options.description_images = Some(value.into()),
"--description-frame" => options.description_frame = Some(value.parse()?),
"--description-loading" => options.description_loading = value == "1",
"--dependency" => options.dependency = Some(value),
"--onboarding-folders" => options.onboarding_folders = Some(value.into()),
"--onboarding-open" => options.onboarding_open = Some(value == "1"),
"--settings-open" => options.settings_open = Some(value == "1"),
"--view" => {
options.view_mode = Some(match value.as_str() {
"table" => 0,
"rows" => 1,
"grid" => 2,
_ => return Err("--view expects table|rows|grid".into()),
})
}
"--pin-dropdown-open" => options.pin_dropdown_open = Some(value == "1"),
"--pointer-press" => options.pointer_press = value == "1",
"--pointer" | "--wheel" => {
let values = value
.split(',')
.map(str::parse::<f32>)
.collect::<std::result::Result<Vec<_>, _>>()?;
if values.iter().any(|v| !v.is_finite()) {
return Err("Pointer values must be finite".into());
}
match (arg.as_str(), values.as_slice()) {
("--pointer", &[x, y]) => options.pointer = Some((x, y)),
("--wheel", &[x, y, dx, dy]) => options.wheel = Some((x, y, dx, dy)),
_ => return Err("Expected --pointer x,y or --wheel x,y,dx,dy".into()),
}
}
"--explore-action-state" => {
options.explore_action = Some(match value.as_str() {
"download" => 1,
"update" => 2,
"remove" => 3,
"folder" => 4,
_ => return Err("Expected download|update|remove|folder".into()),
})
}
"--download-progress" => {
let (name, fraction) = value.split_once('=').ok_or("Expected name=fraction")?;
let fraction: f32 = fraction.parse()?;
if name.is_empty() || !fraction.is_finite() || !(0.0..=1.0).contains(&fraction) {
return Err("Expected name and finite fraction in 0..=1".into());
}
options.download_progress.push((name.into(), fraction));
}
"--confirm-plan" => options.confirm_plan = Some(value.into()),
"--remove-confirm" => options.remove_confirm = Some(value),
"--results-banner" => options.results_banner = Some(value),
"--tab" => {
options.tab = Some(match value.as_str() {
"manage" => 0,
"explore" => 1,
"updates" => 2,
_ => return Err("--tab expects manage, explore or updates".into()),
})
}
"--catalogue" => options.catalogue = Some(value.into()),
"--portal-html" => options.portal_html = Some(value.into()),
"--detail-gallery" => options.detail_gallery = Some(value.parse()?),
"--detail-scroll" => options.detail_scroll = Some(value.parse()?),
"--lightbox" => options.lightbox = Some(value.parse()?),
"--lightbox-zoom" => {
let zoom: f32 = value.parse()?;
if !zoom.is_finite() || !(0.01..=8.0).contains(&zoom) {
return Err("--lightbox-zoom expects a finite scale in 0.01..=8".into());
}
options.lightbox_zoom = Some(zoom);
}
"--portal-full" => options.portal_full = Some(value.into()),
"--portal-updates" => options.portal_updates = Some(value.into()),
"--portal-changelog" => options.portal_changelog = Some(value.parse()?),
"--explore-page" => {
let page = value.parse::<usize>()?;
if page == 0 {
return Err("Page must be positive".into());
}
options.explore_page = Some(page);
}
"--explore-loading" => options.explore_loading = Some(value.parse()?),
"--explore-search" => options.explore_search = Some(value),
"--explore-select" => options.explore_select = Some(value),
"--force-filter-tip" => options.force_filter_tip = Some(filter_index(&value)?),
"--force-exclude-tip" => options.force_exclude_tip = Some(filter_index(&value)?),
"--updates-select" => options.updates_select = Some(value),
"--updates-search" => options.updates_search = Some(value),
"--updates-sort" => {
options.updates_sort = Some(match value.as_str() {
"default" => (-1, true),
"name-asc" => (0, true),
"name-desc" => (0, false),
"local-asc" => (1, true),
"local-desc" => (1, false),
"new-asc" => (2, true),
"new-desc" => (2, false),
"updated-asc" => (3, true),
"updated-desc" => (3, false),
"checked-asc" => (4, true),
"checked-desc" => (4, false),
_ => {
return Err(
"--updates-sort expects default, name-, local-, new-, updated- or checked- followed by asc or desc"
.into(),
);
}
})
}
"--force-search-tip" => options.force_search_tip = Some(value.parse()?),
"--filter-scroll-end" => options.filter_end = Some(value.parse()?),
"--dropdown-open" => options.dropdown_open = Some(value.parse()?),
"--dropdown-hover" => options.dropdown_hover = Some(value.parse()?),
"--dropdown-pressed" => options.dropdown_pressed = Some(value.parse()?),
"--explore-sort" => {
options.explore_sort = Some(match value.as_str() {
"relevance" => fmm_core::explore::Sort::Relevance,
"downloads" => fmm_core::explore::Sort::Downloads,
"updated" => fmm_core::explore::Sort::Updated,
"trending" => fmm_core::explore::Sort::Trending,
_ => {
return Err(
"--explore-sort expects relevance, downloads, updated or trending"
.into(),
);
}
})
}
"--explore-filter" => {
for item in value.split(',') {
let (id, mode) = item
.split_once('=')
.ok_or("--explore-filter expects id=include|exclude|off,…")?;
if !fmm_core::explore::FILTERS.contains(&id) {
return Err(format!("Unknown filter: {id}").into());
}
options.explore_filters.push((
id.into(),
match mode {
"include" => fmm_core::explore::FilterMode::Include,
"exclude" => fmm_core::explore::FilterMode::Exclude,
"off" => fmm_core::explore::FilterMode::Off,
_ => {
return Err(
"--explore-filter expects include, exclude or off".into()
);
}
},
));
}
}
"--screenshot" => options.screenshot = Some(value.into()),
"--fixture" => options.fixture = Some(value.into()),
"--select" => options.select = Some(value),
"--pending" => {
for item in value.split(',').filter(|s| !s.is_empty()) {
let (name, on) = item.split_once('=').ok_or("--pending expects name=0|1,…")?;
options.pending.push((name.into(), on == "1"));
}
}
"--force-tip" => options.force_tip = Some(value.parse()?),
"--force-row-tip" => options.force_row_tip = Some(value.parse()?),
"--pressed-row" => options.pressed_row = Some(value.parse()?),
"--hover-row" => options.hover_row = Some(value.parse()?),
"--hover-checkbox" => options.hover_checkbox = Some(value.parse()?),
"--sort" => {
options.sort = Some(match value.as_str() {
"name-asc" => (0, true),
"name-desc" => (0, false),
"version-asc" => (1, true),
"version-desc" => (1, false),
"enabled-asc" => (2, true),
"enabled-desc" => (2, false),
"default" => (-1, true),
_ => {
return Err(
"--sort expects name-, version- or enabled- followed by asc or desc, or default"
.into(),
);
}
})
}
"--search" => options.search = Some(value),
"--changelog" => options.changelog = Some(value.parse()?),
"--size" => {
let (w, h) = value
.split_once(['x', 'X'])
.ok_or("Size must be WIDTHxHEIGHT")?;
let (w, h) = (w.parse::<u32>()?, h.parse::<u32>()?);
if w == 0 || h == 0 {
return Err("Size must be positive".into());
}
options.size = Some((w, h));
}
_ => return Err(format!("Unknown option: {arg}").into()),
}
}
let m2_capture = options.description_images.is_some()
|| options.description_frame.is_some()
|| options.description_loading
|| options.dependency.is_some()
|| options.onboarding_folders.is_some()
|| options.onboarding_open.is_some()
|| options.settings_open.is_some()
|| options.view_mode.is_some()
|| options.pin_dropdown_open.is_some()
|| options.pointer_press
|| options.pointer.is_some()
|| options.wheel.is_some()
|| options.explore_action.is_some()
|| !options.download_progress.is_empty()
|| options.confirm_plan.is_some()
|| options.remove_confirm.is_some()
|| options.results_banner.is_some();
if m2_capture && (options.screenshot.is_none() || options.fixture.is_none()) {
return Err("State capture flags require --screenshot and --fixture".into());
}
if options.screenshot.is_none()
&& (options.fixture.is_some()
|| options.size.is_some()
|| options.select.is_some()
|| !options.pending.is_empty()
|| options.force_tip.is_some()
|| options.pressed_row.is_some()
|| options.force_row_tip.is_some()
|| options.hover_row.is_some()
|| options.hover_checkbox.is_some()
|| options.sort.is_some()
|| options.search.is_some()
|| options.changelog.is_some()
|| options.tab.is_some()
|| options.catalogue.is_some()
|| options.explore_search.is_some()
|| options.explore_sort.is_some()
|| !options.explore_filters.is_empty()
|| options.explore_select.is_some()
|| options.force_filter_tip.is_some()
|| options.force_exclude_tip.is_some()
|| options.updates_select.is_some()
|| options.updates_search.is_some()
|| options.updates_sort.is_some()
|| options.force_search_tip.is_some()
|| options.filter_end.is_some()
|| options.dropdown_open.is_some()
|| options.dropdown_hover.is_some()
|| options.dropdown_pressed.is_some()
|| options.portal_html.is_some()
|| options.portal_full.is_some()
|| options.portal_updates.is_some()
|| options.portal_changelog.is_some()
|| options.explore_page.is_some()
|| options.detail_gallery.is_some()
|| options.detail_scroll.is_some()
|| options.lightbox.is_some()
|| options.lightbox_zoom.is_some()
|| options.explore_loading.is_some())
{
return Err("--fixture, --size and the capture state options require --screenshot".into());
}
Ok(options)
}
fn capture_model(mut model: model::ManageModel, options: &Options) -> model::ManageModel {
if let Some((column, ascending)) = options.sort {
model.view.sort_column = column;
model.view.ascending = ascending;
}
if let Some(query) = &options.search {
model.view.search_open = true;
model.view.search_text = query.clone();
}
if options.changelog == Some(true) {
model.view.show_changelog = true;
}
model::filter_and_sort(&mut model.rows, &model.view);
model
}
fn run() -> Result<()> {
let started = std::time::Instant::now();
let options = parse_args(std::env::args().skip(1))?;
let mut loaded_settings = settings::Loaded::load();
if options.screenshot.is_none() {
let env = std::env::vars().collect();
let detected = fmm_core::discovery::detect(&env);
loaded_settings.folders = detected.data.clone();
if loaded_settings
.settings
.effective_install_dir(&env)
.is_none()
{
loaded_settings.settings.install_dir = detected.installs.into_iter().next();
}
if loaded_settings.settings.data_dir.is_none()
&& (!cfg!(target_os = "linux") || detected.data.len() == 1)
&& fmm_core::settings::validate_data_dir(
&loaded_settings.settings.effective_data_dir(&env),
)
.is_err()
{
loaded_settings.settings.data_dir = detected.data.into_iter().next();
}
}
let install_dir = loaded_settings
.settings
.effective_install_dir(&std::env::vars().collect());
let catalogue_ttl = loaded_settings.settings.catalogue_ttl();
let data_dir = loaded_settings
.settings
.effective_data_dir(&std::env::vars().collect());
let cache_dir = fmm_core::cache::app_cache_dir()?;
let cache = fmm_core::cache::Cache::new(cache_dir.clone());
let (width, height) = options.size.unwrap_or((1444, 949));
if options.screenshot.is_some() {
capture::init(width, height)?;
} else {
slint::BackendSelector::new()
.backend_name("winit".into())
.renderer_name("femtovg".into())
.select()
.map_err(|e| e.to_string())?;
}
#[cfg(target_os = "linux")]
slint::set_xdg_app_id("factoriomodmanager").map_err(|e| e.to_string())?;
let app = ModsWindow::new().map_err(|e| e.to_string())?;
description::bind_layout(&app);
if let Some(frame) = options.description_frame {
app.global::<DescriptionImages>().set_capture_frame(frame);
}
if options.screenshot.is_none() {
audio::bind(
&app,
loaded_settings.settings.ui_sounds_enabled,
loaded_settings.settings.ui_sound_volume,
);
}
settings::bind(&app, loaded_settings, options.screenshot.is_none());
chrome::bind(&app);
if options.screenshot.is_some() {
bindings::bind_software_lightbox(&app);
}
let mut catalogue_controller;
let mut manage_controller = None;
let mut cleaned = false;
if let Some(fixture) = &options.fixture {
let json: serde_json::Value = serde_json::from_slice(&fs::read(fixture)?)?;
let mut model: model::ManageModel = if let Some(snapshot) = json.get("snapshot") {
let mut c = controller::Controller::new(serde_json::from_value(snapshot.clone())?);
if let Some(name) = json.get("select").and_then(|s| s.as_str()) {
c.select(name);
}
if let Some(toggles) = json.get("toggles").and_then(|s| s.as_array()) {
for name in toggles.iter().filter_map(|n| n.as_str()) {
c.toggle(name);
}
}
if let Some(pin) = json.get("pin-choice").and_then(|s| s.as_i64()) {
c.pin(pin as i32);
}
if let Some(rows) = json.get("downloads") {
c.downloads = serde_json::from_value(rows.clone())?;
}
c.model()
} else {
serde_json::from_value(json.clone())?
};
// Older view fixtures predate the built-in grouping field.
for row in &mut model.rows {
row.builtin |= fmm_core::local_mods::BUILTIN_ORDER.contains(&row.name.as_str());
}
if !model.thumbnail.is_empty() && Path::new(&model.thumbnail).is_relative() {
model.thumbnail = fixture
.parent()
.unwrap_or(Path::new("."))
.join(&model.thumbnail)
.to_string_lossy()
.into_owned();
}
let mut local: Vec<_> = model
.rows
.iter()
.map(|r| fmm_core::local_mods::LocalMod {
name: r.name.clone(),
title: r.title.clone(),
version: r.version.clone(),
author: String::new(),
description: String::new(),
factorio_version: "2.0".into(),
dependencies: vec![],
source: if fmm_core::local_mods::BUILTIN_ORDER.contains(&r.name.as_str()) {
fmm_core::local_mods::ModSource::Builtin
} else {
fmm_core::local_mods::ModSource::Folder
},
path: PathBuf::new(),
thumbnail: None,
})
.collect();
if let Some(value) = json.get("snapshot") {
let snapshot: fmm_core::store::Snapshot = serde_json::from_value(value.clone())?;
local = snapshot.builtin.into_iter().chain(snapshot.mods).collect();
}
let install = install_dir
.clone()
.unwrap_or_else(|| fmm_core::paths::DEFAULT_INSTALL_DIRS[0].into());
let locale = fs::read_to_string(install.join("data/core/locale/en/core.cfg"))
.map(|s| fmm_core::locale::Locale::parse(&s))
.unwrap_or_default();
let game_version = json
.get("game-version")
.and_then(|v| v.as_str())
.unwrap_or("2.0.77");
catalogue_controller =
catalogue::CatalogueController::from_local(local, game_version, locale);
bindings::publish(
&app,
capture_model(model, &options),
json.get("error")
.and_then(|v| v.as_str())
.unwrap_or_default(),
);
if let Some(mixed) = json.get("mixed").and_then(|v| v.as_bool()) {
app.set_mixed(mixed);
}
if let Some(checked) = json.get("all-checked").and_then(|v| v.as_bool()) {
app.set_all_checked(checked);
}
if let Some(tip) = json.get("force-dependency-tip").and_then(|v| v.as_i64()) {
app.set_force_dependency_tip(tip as i32);
}
if let Some(tab) = json.get("current-tab").and_then(|v| v.as_i64()) {
app.set_current_tab(tab as i32);
}
} else {
match load_snapshot_with_data(install_dir.as_deref(), Some(&data_dir), &cache_dir) {
Ok(snapshot) => {
catalogue_controller = catalogue::CatalogueController::new(&snapshot);
if options.screenshot.is_some() {
// Capture is data-only: no write or quit callbacks are installed.
let mut c = controller::Controller::new(snapshot);
if let Some(name) = &options.select {
c.select(name);
}
for (name, on) in &options.pending {
c.pending =
fmm_core::enable::set_pending(&c.snapshot, &c.pending, name, *on);
}
bindings::publish(&app, capture_model(c.model(), &options), "");
} else {
let effects = Rc::new(RefCell::new(bindings::StoreEffects));
if !fmm_core::store::is_factorio_running() {
match fmm_core::download::clean_temp_for(&snapshot.paths) {
Ok(_) => cleaned = true,
Err(e) => app.set_results_banner(
format!("Temporary download cleanup failed: {e}").into(),
),
}
}
manage_controller = Some(bindings::bind_manage(&app, snapshot, effects));
}
}
Err(e) => {
let error = format!("Cannot load Factorio: {e}");
bindings::publish(&app, model::ManageModel::default(), &error);
app.set_install_ready(false);
app.set_settings_error(error.into());
if options.screenshot.is_none() {
app.set_onboarding_open(true);
}
catalogue_controller =
catalogue::CatalogueController::from_local(vec![], "2.0", Default::default());
}
}
}
if options.screenshot.is_none() || std::env::var_os("FMM_METADATA_DIR").is_some() {
let store = fmm_core::metadata::MetadataStore::new(fmm_core::metadata::app_metadata_dir()?);
catalogue_controller.load_metadata(&store);
}
let catalogue_path = options
.catalogue
.clone()
.unwrap_or_else(|| cache_dir.join("catalogue.json"));
if options.screenshot.is_none() {
bindings::bind_detail_links(&app, bindings::open_browser);
}
let _live;
if options.screenshot.is_some() {
catalogue_controller.set_catalogue(catalogue::load_index(
&catalogue_path,
&catalogue_controller.game_version,
));
if let Some(query) = &options.explore_search {
catalogue_controller.view.search = query.clone();
}
if let Some(sort) = options.explore_sort {
catalogue_controller.view.sort = sort;
}
for (id, mode) in &options.explore_filters {
catalogue_controller.view.set_filter(id, *mode);
}
if let Some(page) = options.explore_page {
catalogue_controller.page = page;
}
if let Some(html) = &options.portal_html {
match fs::read_to_string(html)
.map_err(fmm_core::Error::from)
.and_then(|s| {
fmm_core::portal_search::parse(std::str::from_utf8(
fmm_core::portal_data::response_bytes(s.as_bytes()),
)?)
}) {
Ok(page) => catalogue_controller.portal_page = Some(page),
Err(e) => {
eprintln!("Capture portal failure: {e}");
catalogue_controller.notice =
"Portal search unavailable; showing cached catalogue".into();
}
}
}
if let Some(path) = &options.portal_full {
let bytes = fs::read(path)?;
match serde_json::from_slice::<fmm_core::portal::PortalModFull>(
fmm_core::portal_data::response_bytes(&bytes),
) {
Ok(full) => {
catalogue_controller
.full
.insert(full.mod_.name.clone(), full);
}
Err(e) => app.set_results_banner(
format!("Cannot load mod details from the mod portal: {e}").into(),
),
}
}
if let Some(path) = &options.portal_updates {
match fmm_core::catalogue::Catalogue::parse(fmm_core::portal_data::response_bytes(
&fs::read(path)?,
)) {
Ok(catalogue) => catalogue_controller.set_updates(&catalogue.results),
Err(_) => catalogue_controller.updates_failed = true,
}
}
if let Some(name) = &options.explore_select {
catalogue_controller.select(name);
}
if let Some(name) = &options.updates_select {
catalogue_controller.select(name);
}
if let Some(action) = options.explore_action {
let name = options
.explore_select
.as_ref()
.or(options.updates_select.as_ref())
.ok_or("--explore-action-state requires --explore-select or --updates-select")?;
catalogue_controller.capture_action(name, action);
}
if let Some(sort) = options.updates_sort {
catalogue_controller.update_sort = sort;
}
if let Some(query) = &options.updates_search {
catalogue_controller.update_search = query.clone();
catalogue_controller.update_search_open = true;
}
let mut urls: Vec<_> = catalogue_controller
.visible_mods()
.into_iter()
.chain(catalogue_controller.selected_mod())
.filter_map(|m| fmm_core::portal::thumbnail_url(m.thumbnail.as_deref()))
.collect();
for full in catalogue_controller.full.values() {
urls.extend(
full.images
.iter()
.flat_map(|image| [image.thumbnail.clone(), image.url.clone()]),
);
urls.extend(
fmm_core::markdown::parse(full.description.as_deref().unwrap_or_default())
.into_iter()
.filter(|b| b.kind == fmm_core::markdown::Kind::Image)
.flat_map(|b| b.images.into_iter().map(|i| i.url)),
);
urls.extend(fmm_core::portal::thumbnail_url(
full.mod_.thumbnail.as_deref(),
));
}
let data = fmm_core::portal_data::PortalData {
fetcher: fmm_core::net::Http::default(),
cache: cache.clone(),
};
for url in urls {
if let Ok(path) = data.thumbnail_path(&url)
&& path.is_file()
&& let Ok(image) = slint::Image::load_from_path(&path)
{
catalogue_controller.thumbnails.insert(url, image);
}
}
if !options.description_loading && options.tab.unwrap_or(app.get_current_tab()) != 0 {
let fixtures = options
.description_images
.as_ref()
.map(|p| {
fs::read(p).and_then(|bytes| {
serde_json::from_slice::<std::collections::HashMap<String, PathBuf>>(&bytes)
.map_err(std::io::Error::other)
})
})
.transpose()?
.unwrap_or_default();
let transport = description::FixtureTransport(fixtures);
for full in catalogue_controller.full.values() {
for item in
fmm_core::markdown::parse(full.description.as_deref().unwrap_or_default())
.into_iter()
.flat_map(|b| b.images)
{
let result = if options.description_images.is_some() {
fmm_core::description_images::fetch(&transport, &cache, &item.url)
} else {
fmm_core::description_images::cached_path(&cache, &item.url)
};
let result =
result.and_then(|p| fmm_core::description_images::decode(&fs::read(p)?));
let mut images = catalogue_controller.description_images.borrow_mut();
match result {
Ok(decoded) => images.insert(item.url, decoded),
Err(_) => {
images.failed.insert(item.url);
}
}
}
}
}
if let Some(name) = &options.dependency {
catalogue_controller.focus_dependency(name);
}
let detail_started = std::time::Instant::now();
for (name, fraction) in &options.download_progress {
catalogue_controller
.progress
.insert(name.clone(), *fraction);
}
if let Some(name) = &options.updates_select {
app.set_updates_picked(name.into());
}
catalogue_controller.publish(&app);
eprintln!("Detail projection: {:?}", detail_started.elapsed());
app.set_explore_loading(options.explore_loading == Some(true));
if options.portal_changelog == Some(true) {
app.set_show_portal_changelog(true);
}
_live = None;
} else if let Some(manage) = manage_controller {
let c = catalogue::bind(&app, catalogue_controller);
operations::bind(&app, manage, c.clone(), cache.clone(), cleaned);
_live = Some(live::start(&app, c, cache, catalogue_ttl));
} else {
app.on_request_close(|| {
let _ = slint::quit_event_loop();
});
_live = None;
}
if options.settings_open == Some(true) {
app.set_settings_open(true);
}
if let Some(path) = &options.onboarding_folders {
let folders: Vec<String> = serde_json::from_slice(&fs::read(path)?)?;
app.set_detected_data_folders(slint::ModelRc::new(slint::VecModel::from(
folders
.into_iter()
.map(slint::SharedString::from)
.collect::<Vec<_>>(),
)));
}
if options.onboarding_open == Some(true) {
app.set_onboarding_open(true);
}
if let Some(mode) = options.view_mode {
app.set_manage_view(mode);
app.set_updates_view(mode);
app.set_explore_view(mode.max(1));
}
app.set_force_pin_open(options.pin_dropdown_open.unwrap_or(false));
if let Some(tab) = options.tab {
app.set_current_tab(tab);
}
for (name, fraction) in &options.download_progress {
app.set_batch_busy(true);
app.set_download_name(name.into());
app.set_download_fraction(*fraction);
app.set_download_label(format!("{}%", (fraction * 100.0) as u32).into());
app.set_batch_status(format!("Downloading {name}: 4,600,000 / 10,000,000 bytes").into());
}
if let Some(path) = &options.confirm_plan {
#[derive(serde::Deserialize)]
struct CaptureDialog {
title: String,
lines: Vec<String>,
confirm: bool,
}
let d: CaptureDialog = serde_json::from_slice(&fs::read(path)?)?;
operations::show_dialog(
&app,
operations::Dialog {
title: d.title,
lines: d.lines,
confirm: d.confirm,
},
);
}
if let Some(name) = &options.remove_confirm {
operations::show_dialog(
&app,
operations::Dialog {
title: "Remove mod".into(),
lines: vec![format!(
"Move {name} to the {TRASH_NAME}? The game will no longer load it."
)],
confirm: true,
},
);
}
if let Some(text) = &options.results_banner {
app.set_results_banner(text.into());
}
if let Some(out) = options.screenshot {
if let Some(tip) = options.force_tip {
app.set_force_dependency_tip(tip);
}
app.set_force_filter_tip(options.force_filter_tip.unwrap_or(-1));
app.set_force_exclude_tip(options.force_exclude_tip.unwrap_or(-1));
if let Some(name) = &options.updates_select {
app.set_updates_picked(name.into());
}
app.set_force_search_tip(options.force_search_tip.unwrap_or(false));
app.set_force_filter_end(options.filter_end.unwrap_or(false));
app.set_force_dropdown_open(
options.dropdown_open.unwrap_or(false)
|| options.dropdown_hover.is_some()
|| options.dropdown_pressed.is_some(),
);
app.set_force_dropdown_hover(options.dropdown_hover.unwrap_or(-1));
app.set_force_dropdown_pressed(options.dropdown_pressed.unwrap_or(-1));
app.set_detail_gallery(options.detail_gallery.unwrap_or(-1));
app.set_detail_scroll(-options.detail_scroll.unwrap_or(0.0));
app.set_force_row_tip(options.force_row_tip.unwrap_or(-1));
app.set_force_pressed_row(options.pressed_row.unwrap_or(-1));
app.set_force_hover_row(options.hover_row.unwrap_or(-1));
if let Some(row) = options.hover_checkbox {
app.show().map_err(|e| e.to_string())?;
// Initialize the list layout, then send a real pointer move onto its 14px checkbox.
let _ = app.window().take_snapshot().map_err(|e| e.to_string())?;
app.window()
.dispatch_event(slint::platform::WindowEvent::PointerMoved {
position: slint::LogicalPosition::new(55.0, 186.0 + row as f32 * 28.0),
});
}
if options.portal_full.is_some() {
let detail_started = std::time::Instant::now();
app.show().map_err(|e| e.to_string())?;
let _ = app.window().take_snapshot().map_err(|e| e.to_string())?;
eprintln!(
"Details instantiation + layout + first render: {:?}",
detail_started.elapsed()
);
}
if let Some(index) = options.lightbox {
use slint::Model;
let image = app
.get_portal_detail()
.gallery
.row_data(index)
.ok_or("--lightbox gallery index out of range")?;
if image.source.size().width == 0 {
return Err("--lightbox image is not cached".into());
}
app.set_lightbox_source(image.source);
app.set_lightbox_zoom(options.lightbox_zoom.unwrap_or(0.0));
app.set_lightbox_open(true);
}
if options.pointer.is_some() || options.wheel.is_some() {
use slint::{LogicalPosition, platform::WindowEvent};
app.show().map_err(|e| e.to_string())?;
let _ = app.window().take_snapshot().map_err(|e| e.to_string())?;
if let Some((x, y)) = options.pointer {
app.window().dispatch_event(WindowEvent::PointerMoved {
position: LogicalPosition::new(x, y),
});
if options.pointer_press {
app.window().dispatch_event(WindowEvent::PointerPressed {
position: LogicalPosition::new(x, y),
button: slint::platform::PointerEventButton::Left,
});
}
}
if let Some((x, y, dx, dy)) = options.wheel {
app.window().dispatch_event(WindowEvent::PointerScrolled {
position: LogicalPosition::new(x, y),
delta_x: dx,
delta_y: dy,
});
}
}
capture::save(&app, &out, width, height, started)?;
println!(
"{}: {width}x{height} (Slint software, scale 1)",
out.display()
);
} else {
app.run().map_err(|e| e.to_string())?;
}
Ok(())
}
/// A GUI-subsystem exe starts without a console. When a terminal launched it, reattach to that one so
/// the messages (and `--screenshot` output) still show there. Without a parent console (Explorer,
/// Start menu) the call fails and nothing is created.
#[cfg(windows)]
fn attach_parent_console() {
unsafe extern "system" {
fn AttachConsole(process_id: u32) -> i32;
}
const ATTACH_PARENT_PROCESS: u32 = u32::MAX;
// SAFETY: plain Win32 call with no pointers.
unsafe { AttachConsole(ATTACH_PARENT_PROCESS) };
}
fn main() {
#[cfg(windows)]
attach_parent_console();
if let Err(error) = run() {
eprintln!("{error}");
std::process::exit(1);
}
}
#[cfg(test)]
mod tests;