use crate::{ModsWindow, UiSounds};
use fmm_core::settings::{self, Settings};
use slint::ComponentHandle;
use std::{cell::RefCell, path::PathBuf, rc::Rc};
pub struct Loaded {
pub settings: Settings,
pub folders: Vec<PathBuf>,
dir: Option<PathBuf>,
error: String,
first_run: bool,
}
impl Loaded {
pub fn load() -> Self {
match settings::settings_dir() {
Ok(dir) => {
let first_run = !dir.join("settings.json").is_file();
match settings::load(&dir) {
Ok(settings) => Self {
folders: vec![],
settings,
dir: Some(dir),
error: String::new(),
first_run,
},
Err(e) => Self {
folders: vec![],
settings: Settings::default(),
dir: Some(dir),
first_run,
error: format!(
"Cannot load settings: {e}. Save settings to replace the file."
),
},
}
}
Err(e) => Self {
folders: vec![],
settings: Settings::default(),
dir: None,
error: e.to_string(),
first_run: true,
},
}
}
}
fn publish(app: &ModsWindow, settings: &Settings) {
let env = std::env::vars().collect();
app.set_settings_verify(settings.verify_downloads);
app.set_settings_sounds(settings.ui_sounds_enabled);
app.set_settings_volume(i32::from(settings.ui_sound_volume));
app.global::<UiSounds>().invoke_update(
settings.ui_sounds_enabled,
i32::from(settings.ui_sound_volume),
);
app.set_settings_data(
settings
.effective_data_dir(&env)
.to_string_lossy()
.into_owned()
.into(),
);
let install = settings.effective_install_dir(&env).or_else(|| {
fmm_core::paths::DEFAULT_INSTALL_DIRS
.iter()
.map(PathBuf::from)
.find(|p| fmm_core::paths::read_game_version(p).is_ok())
});
app.set_settings_install(
install
.map(|p| p.to_string_lossy().into_owned())
.unwrap_or_default()
.into(),
);
}
pub fn bind(app: &ModsWindow, loaded: Loaded, writable: bool) {
app.set_verify_downloads(loaded.settings.verify_downloads);
publish(app, &loaded.settings);
app.set_data_folder(app.get_settings_data());
app.set_install_folder(app.get_settings_install());
if std::env::var_os("FACTORIO_DIR").is_some_and(|s| !s.is_empty()) {
app.set_settings_environment_note(
"FACTORIO_DIR overrides the saved install folder. Folder changes apply after restart."
.into(),
);
}
app.set_settings_error(loaded.error.clone().into());
app.set_settings_open(writable && !loaded.error.is_empty());
app.set_onboarding_open(
writable
&& (loaded.first_run
|| (cfg!(target_os = "linux")
&& loaded.settings.data_dir.is_none()
&& loaded.folders.len() > 1)
|| settings::validate_data_dir(&PathBuf::from(app.get_data_folder().as_str()))
.is_err()),
);
if writable {
let folders = loaded.folders.clone();
let native = fmm_core::paths::default_user_dir(&std::env::vars().collect());
app.set_detected_data_folders(slint::ModelRc::new(slint::VecModel::from(
folders
.iter()
.map(|p| {
format!(
"{}{}",
p.display(),
if p == &native { " (recommended)" } else { "" }
)
.into()
})
.collect::<Vec<slint::SharedString>>(),
)));
let weak = app.as_weak();
app.on_data_folder_picked(move |index| {
if let Some(app) = weak.upgrade()
&& let Some(folder) = folders.get(index as usize)
{
app.set_settings_data(folder.to_string_lossy().into_owned().into());
app.set_settings_open(true);
app.set_settings_error(
"Review the folders and save settings, then restart to use this data folder."
.into(),
);
}
});
}
let settings = Rc::new(RefCell::new(loaded.settings));
let current = settings.clone();
let weak = app.as_weak();
app.on_settings_requested(move || {
if let Some(app) = weak.upgrade() {
publish(&app, ¤t.borrow());
app.set_settings_error("".into());
app.set_settings_open(true);
}
});
let current = settings.clone();
let weak = app.as_weak();
app.on_settings_cancel(move || {
if let Some(app) = weak.upgrade() {
publish(&app, ¤t.borrow());
app.set_settings_open(false);
}
});
if !writable {
return;
}
let dir = loaded.dir.clone();
let weak = app.as_weak();
app.on_onboarding_continue(move || {
if let Some(app) = weak.upgrade() {
let result = (|| -> fmm_core::Result<()> {
let mut next =
Settings::from_inputs(&app.get_data_folder(), &app.get_install_folder())?;
next.verify_downloads = app.get_verify_downloads();
next.ui_sounds_enabled = app.global::<UiSounds>().get_enabled();
next.ui_sound_volume = app.global::<UiSounds>().get_volume().clamp(0, 100) as u8;
settings::save(
dir.as_deref()
.ok_or("Settings directory is unavailable; set FMM_SETTINGS_DIR.")?,
&next,
)
})();
match result {
Ok(()) => {
app.set_onboarding_open(false);
app.set_settings_error("".into());
}
Err(e) => {
crate::audio::cannot(&app);
app.set_settings_error(e.to_string().into());
}
}
}
});
let weak = app.as_weak();
app.on_settings_save(move || {
if let Some(app) = weak.upgrade() {
let result = (|| -> fmm_core::Result<Settings> {
let mut next =
Settings::from_inputs(&app.get_settings_data(), &app.get_settings_install())?;
next.verify_downloads = app.get_settings_verify();
next.ui_sounds_enabled = app.get_settings_sounds();
next.ui_sound_volume = app.get_settings_volume().clamp(0, 100) as u8;
settings::save(
loaded
.dir
.as_deref()
.ok_or("Settings directory is unavailable; set FMM_SETTINGS_DIR.")?,
&next,
)?;
Ok(next)
})();
match result {
Ok(next) => {
app.global::<UiSounds>()
.invoke_update(next.ui_sounds_enabled, i32::from(next.ui_sound_volume));
app.set_verify_downloads(next.verify_downloads);
*settings.borrow_mut() = next;
app.set_settings_open(false);
// Keep startup paths truthful until the app is restarted.
app.set_onboarding_open(false);
app.set_results_banner(
"Settings saved. Restart the mod manager to apply the folder changes."
.into(),
);
}
Err(e) => {
crate::audio::cannot(&app);
app.set_settings_error(e.to_string().into());
}
}
}
});
}
#[cfg(test)]
mod tests {
use super::*;
use crate::tests::common;
fn loaded(dir: &common::TempDir) -> Loaded {
let data = dir.0.join("data");
std::fs::create_dir_all(data.join("mods")).unwrap();
std::fs::write(data.join("mods/mod-list.json"), r#"{"mods":[]}"#).unwrap();
Loaded {
folders: vec![],
settings: Settings {
data_dir: Some(data),
install_dir: None,
..Default::default()
},
dir: Some(dir.0.clone()),
error: String::new(),
first_run: true,
}
}
#[test]
fn settings_validate_persist_and_discard_in_temp_dirs() {
let dir = common::TempDir::new();
crate::capture::init(1000, 600).unwrap();
let app = ModsWindow::new().unwrap();
let mut value = loaded(&dir);
// Keep the test independent of the owner's detected installation.
value.settings.install_dir = None;
bind(&app, value, true);
app.set_install_folder("".into());
assert!(app.get_onboarding_open());
app.invoke_onboarding_continue();
assert!(!app.get_onboarding_open());
assert!(dir.0.join("settings.json").exists());
app.invoke_settings_requested();
let data = app.get_settings_data();
app.set_settings_data("relative".into());
app.invoke_settings_save();
assert!(app.get_settings_open());
assert!(!app.get_settings_error().is_empty());
app.set_settings_data(data.clone());
app.set_settings_install("".into());
app.invoke_settings_save();
assert!(!app.get_settings_open());
assert!(app.get_results_banner().contains("Restart"));
assert_eq!(
settings::load(&dir.0).unwrap().data_dir,
Some(PathBuf::from(data.as_str()))
);
app.invoke_settings_requested();
app.set_settings_data("discard me".into());
app.set_settings_open(false);
app.invoke_settings_requested();
assert_eq!(app.get_settings_data(), data);
app.show().unwrap();
let _ = app.window().take_snapshot().unwrap();
use slint::platform::{Key, WindowEvent};
for event in [
WindowEvent::KeyPressed {
text: Key::Escape.into(),
},
WindowEvent::KeyReleased {
text: Key::Escape.into(),
},
] {
app.window().dispatch_event(event);
}
assert!(!app.get_settings_open());
app.hide().unwrap();
}
#[test]
fn sound_drafts_preview_cancel_save_and_failed_save_keep_preferences() {
let dir = common::TempDir::new();
crate::capture::init(1000, 600).unwrap();
let app = ModsWindow::new().unwrap();
bind(&app, loaded(&dir), true);
app.invoke_settings_requested();
assert!(app.get_settings_sounds());
assert_eq!(app.get_settings_volume(), 50);
app.set_settings_sounds(false);
app.set_settings_volume(12);
app.global::<UiSounds>().invoke_update(false, 12);
app.invoke_settings_cancel();
assert!(app.global::<UiSounds>().get_enabled());
assert_eq!(app.global::<UiSounds>().get_volume(), 50);
assert!(!dir.0.join("settings.json").exists());
app.invoke_settings_requested();
app.set_settings_install("".into());
app.set_settings_volume(0);
app.global::<UiSounds>().invoke_update(true, 0);
app.invoke_settings_save();
assert_eq!(settings::load(&dir.0).unwrap().ui_sound_volume, 0);
let before = std::fs::read(dir.0.join("settings.json")).unwrap();
app.invoke_settings_requested();
app.set_settings_data("invalid".into());
app.set_settings_volume(70);
app.global::<UiSounds>().invoke_update(true, 70);
app.invoke_settings_save();
assert!(app.get_settings_open());
assert_eq!(app.get_settings_volume(), 70);
assert_eq!(std::fs::read(dir.0.join("settings.json")).unwrap(), before);
app.invoke_settings_cancel();
assert_eq!(app.global::<UiSounds>().get_volume(), 0);
}
#[test]
fn capture_settings_never_bind_save_or_onboarding_writes() {
let dir = common::TempDir::new();
crate::capture::init(1000, 600).unwrap();
let app = ModsWindow::new().unwrap();
bind(&app, loaded(&dir), false);
assert!(!app.get_onboarding_open());
app.invoke_settings_requested();
app.invoke_settings_save();
app.invoke_onboarding_continue();
assert!(app.get_settings_open());
assert!(!dir.0.join("settings.json").exists());
}
}
#[cfg(all(test, target_os = "linux"))]
mod linux_tests {
use super::*;
#[test]
fn ambiguous_data_without_saved_choice_keeps_onboarding_selection() {
let dir = crate::tests::common::TempDir::new();
crate::capture::init(1000, 600).unwrap();
let app = ModsWindow::new().unwrap();
let folders = vec![dir.0.join("native"), dir.0.join("flatpak")];
bind(
&app,
Loaded {
settings: Settings::default(),
folders: folders.clone(),
dir: Some(dir.0.join("settings")),
error: String::new(),
first_run: false,
},
true,
);
assert!(app.get_onboarding_open());
app.invoke_data_folder_picked(1);
assert_eq!(
app.get_settings_data().as_str(),
folders[1].to_str().unwrap()
);
assert!(!dir.0.join("settings/settings.json").exists());
}
}