Merge pull request #1154 from ludovic111/feat/mod-browser-page

🤖 Agent: merged. Verify passes (launcher only). Mod browser part 3/3: the launcher's Mods page, with screenshots in the body.
This commit is contained in:
Ludovic Marie
2026-10-22 05:04:25 +02:00
committed by GitHub
5 changed files with 702 additions and 3 deletions
+9
View File
@@ -30,6 +30,15 @@ never offered for install.
else removes the part file and installs nothing.
- A file whose source lists no checksum is refused.
## The Mods page
The launcher's **Mods** page has the three kinds as tabs, a search field (Enter searches), **Show everything** and,
once CurseForge is set up, a Modrinth / CurseForge switch. Each result is an index row: its summary, author,
downloads, source and licence, how well it runs (and why), **Page** (the project's page on its source) and
**Install** (**Import** for a modpack). Installed packs are listed above the results with their version, source,
file and the checksum they were checked against, with **Update to …** when a newer version runs and **Remove**
(asked twice).
## Installing, updating, removing
`mod-browser.json` beside `options.txt` lists every file the browser installed: its source, project, version, file
+6
View File
@@ -24,6 +24,12 @@ The opening, then Play ([clip](docs/opening.webm)):
preparation reuses checksum-verified game jars and libraries from the current
or another installed Horizon version, so the original Minecraft install is
only required when no valid imported copy exists.
- **Mods**: search Modrinth (and CurseForge once the launcher has its API key) for resource
packs, Iris/OptiFine shader packs and modpacks, each marked Works, Partly or Doesn't run in
Horizon; Java mod jars are never offered. Install puts a pack and what it needs in
`resourcepacks/` or `shaderpacks/` only after its SHA-512 (SHA-1 on CurseForge) matches, and a
modpack goes to the Modpacks page; installed packs show their source and checksum, with Update
and Remove ([docs/mod-browser.md](../docs/mod-browser.md)).
- **Modpacks**: import a Java modpack (a Modrinth `.mrpack`, a CurseForge zip, or a Prism,
MultiMC or CurseForge instance folder) and see its coverage report: per mod, ported, partial,
not yet or not needed, with the reason ([docs/modpacks.md](../docs/modpacks.md)). **Port**
+10 -1
View File
@@ -8,6 +8,7 @@ mod internet;
mod markdown;
mod mcp;
mod modpacks_page;
mod mods_page;
mod perf;
mod scrollbar;
mod servers_page;
@@ -35,6 +36,7 @@ use theme::Theme;
enum Page {
Play,
Versions,
Mods,
Modpacks,
Servers,
Notes,
@@ -42,9 +44,10 @@ enum Page {
}
impl Page {
const ALL: [(Page, &'static str); 6] = [
const ALL: [(Page, &'static str); 7] = [
(Page::Play, "Play"),
(Page::Versions, "Versions"),
(Page::Mods, "Mods"),
(Page::Modpacks, "Modpacks"),
(Page::Servers, "Servers"),
(Page::Notes, "Patch notes"),
@@ -181,6 +184,8 @@ struct Launcher {
pack_error: Option<String>,
/// The game starting now plays this pack's profile (its work folder).
starting_pack: Option<std::path::PathBuf>,
/// The Mods page: the browser's search, installs and updates (`mods_page.rs`).
mods: mods_page::Mods,
}
impl Launcher {
@@ -291,6 +296,7 @@ impl Launcher {
pack_log: VecDeque::new(),
pack_error: None,
starting_pack: None,
mods: mods_page::Mods::new(cx),
};
if this.bench.is_some() {
this.perf.keep_local_log(false);
@@ -595,6 +601,7 @@ impl Launcher {
}
}
changed |= self.servers_tick();
changed |= self.mods_tick();
if let Some(sign_in) = &self.sign_in {
let state = sign_in.state();
let changed_state = format!("{state:?}") != format!("{:?}", self.sign_in_state);
@@ -2687,10 +2694,12 @@ impl Render for Launcher {
self.perf.frame();
self.servers.note_focus(window);
self.friend_focused = self.friend_focus.is_focused(window);
self.mods.note_focus(window);
self.args_focused = self.args_focus.is_focused(window);
let content = match self.page {
Page::Play => self.play_page(cx),
Page::Versions => self.versions_page(cx),
Page::Mods => self.mods_page(cx),
Page::Modpacks => self.modpacks_page(cx),
Page::Servers => self.servers_page(cx),
Page::Notes => self.notes_page(cx),
+675
View File
@@ -0,0 +1,675 @@
//! The Mods page: search Modrinth (and CurseForge with a key) for resource packs, shader packs
//! and modpacks Horizon loads, see where each comes from and how well it runs, install it with
//! its checksum checked, and update or remove what was installed (`horizon_launcher::browser`).
use super::servers_page::{type_key, Key};
use super::*;
use horizon_launcher::browser::{
self, curseforge::CurseForge, installed, Kind as PackKind, Project, Query, SourceId, Support,
};
use horizon_launcher::modpacks;
use std::collections::HashMap;
const KINDS: [(PackKind, &str); 3] = [
(PackKind::ResourcePack, "Resource packs"),
(PackKind::ShaderPack, "Shader packs"),
(PackKind::Modpack, "Modpacks"),
];
const SOURCES: [(SourceId, &str); 2] = [
(SourceId::Modrinth, "Modrinth"),
(SourceId::CurseForge, "CurseForge"),
];
const PAGE: usize = 20;
pub(super) enum Event {
/// A search's answer, for the search it was (stale answers are dropped) at that offset.
Found(u64, usize, Result<Vec<Project>, String>),
Progress(String, f32),
Done(Result<String, String>, bool),
Updates(HashMap<(SourceId, String), String>),
}
pub(super) struct Mods {
kind: PackKind,
source: SourceId,
curseforge: bool,
text: String,
focus: FocusHandle,
pub(super) focused: bool,
everything: bool,
/// Which search is the current one; answers for older ones are dropped.
search: u64,
searching: bool,
searched: bool,
results: Vec<Project>,
more: bool,
error: Option<String>,
installed: Vec<installed::Entry>,
loaded: bool,
/// The project being installed, and the line and fraction of its download.
busy: Option<(String, String, f32)>,
message: Option<Result<String, String>>,
updates: HashMap<(SourceId, String), String>,
confirm_remove: Option<String>,
tx: Sender<Event>,
rx: Receiver<Event>,
}
impl Mods {
pub(super) fn new(cx: &mut App) -> Self {
let (tx, rx) = channel();
Self {
kind: PackKind::ResourcePack,
source: SourceId::Modrinth,
curseforge: CurseForge::from_env().is_some(),
text: String::new(),
focus: cx.focus_handle().tab_index(0).tab_stop(true),
focused: false,
everything: false,
search: 0,
searching: false,
searched: false,
results: Vec::new(),
more: false,
error: None,
installed: Vec::new(),
loaded: false,
busy: None,
message: None,
updates: HashMap::new(),
confirm_remove: None,
tx,
rx,
}
}
pub(super) fn note_focus(&mut self, window: &Window) {
self.focused = self.focus.is_focused(window);
}
fn entry(&self, p: &Project) -> Option<&installed::Entry> {
self.installed
.iter()
.find(|e| e.source == p.source && e.project == p.id)
}
}
/// `51404735` → `51.4M`.
fn count(n: u64) -> String {
match n {
0..1_000 => n.to_string(),
1_000..1_000_000 => format!("{:.1}k", n as f64 / 1e3),
_ => format!("{:.1}M", n as f64 / 1e6),
}
}
/// A checksum as the page shows it: the algorithm and the first and last hex digits.
fn short_sum(checksum: &str) -> String {
let (algo, hex) = checksum.split_once(':').unwrap_or(("", checksum));
if hex.len() <= 20 {
return checksum.to_string();
}
format!("{algo} {}…{}", &hex[..12], &hex[hex.len() - 8..])
}
impl Launcher {
/// Called with the launcher's other work: what the background sent.
pub(super) fn mods_tick(&mut self) -> bool {
let mut changed = false;
while let Ok(event) = self.mods.rx.try_recv() {
changed = true;
let m = &mut self.mods;
match event {
Event::Found(search, offset, result) if search == m.search => {
m.searching = false;
m.searched = true;
match result {
Ok(found) => {
m.more = found.len() == PAGE;
m.results.truncate(offset);
m.results.extend(found);
m.error = None;
}
Err(e) => m.error = Some(e),
}
}
Event::Found(..) => {}
Event::Progress(line, f) => {
if let Some(busy) = &mut m.busy {
busy.1 = line;
busy.2 = f;
}
}
Event::Done(result, modpack) => {
m.busy = None;
m.message = Some(result);
m.installed = installed::Installed::load(&backend::game_home()).entries;
if modpack {
// The Modpacks page reads its list again.
self.packs_loaded = None;
}
}
Event::Updates(found) => m.updates = found,
}
}
changed
}
fn mods_search(&mut self, offset: usize) {
let m = &mut self.mods;
m.search += 1;
m.searching = true;
if offset == 0 {
m.results.clear();
m.more = false;
}
let query = Query {
everything: m.everything,
offset,
limit: PAGE,
..Query::new(&m.text, m.kind)
};
let (tx, search, source) = (m.tx.clone(), m.search, m.source);
std::thread::spawn(move || {
let result = browser::source(source)
.ok_or_else(|| format!("{} isn't set up.", source.label()))
.and_then(|s| s.search(&query));
let _ = tx.send(Event::Found(search, offset, result));
});
}
/// Looks for newer versions of what the browser installed.
fn mods_check_updates(&mut self) {
let entries = self.mods.installed.clone();
if entries.is_empty() {
return;
}
let tx = self.mods.tx.clone();
std::thread::spawn(move || {
let mut found = HashMap::new();
for e in entries {
let Some(source) = browser::source(e.source) else {
continue;
};
if let Ok(Some(v)) = installed::update_for(&*source, &e) {
found.insert((e.source, e.project.clone()), v.number);
}
}
let _ = tx.send(Event::Updates(found));
});
}
/// Installs (or updates) a project on a thread: a pack into its folder, a modpack into
/// Modpacks. `known` is the project when the page has it; else it is asked for first.
fn mods_install(&mut self, source: SourceId, id: String, known: Option<Project>) {
if self.mods.busy.is_some() {
return;
}
self.mods.message = None;
self.mods.busy = Some((id.clone(), format!("Asking {}…", source.label()), 0.));
self.mods.updates.remove(&(source, id.clone()));
let (tx, everything) = (self.mods.tx.clone(), self.mods.everything);
std::thread::spawn(move || {
let last = std::cell::Cell::new(-1);
let progress = |line: &str, f: f32| {
let pct = (f * 100.) as i32;
if last.replace(pct) != pct {
let _ = tx.send(Event::Progress(line.to_string(), f));
}
};
let mut modpack = false;
let result = browser::source(source)
.ok_or_else(|| format!("{} isn't set up.", source.label()))
.and_then(|source| {
let p = match known {
Some(p) => p,
None => source.project(&id)?,
};
modpack = p.kind == PackKind::Modpack;
if modpack {
let folder = modpacks::ports_dir().join("downloads");
let file = installed::fetch_modpack(&*source, &p, &folder, &|f| {
progress(&p.title, f)
})?;
let log = |line: String| progress(&line, 1.);
let pack = modpacks::import(&file, &log)?;
return Ok(format!(
"{} is imported: open it on the Modpacks page to port it.",
pack.title()
));
}
let home = backend::game_home();
let done = installed::install(&*source, &p, everything, &home, &progress)?;
let names: Vec<String> = done
.iter()
.map(|e| format!("{} {}", e.title, e.number))
.collect();
let turn_on = match p.kind {
PackKind::ShaderPack => "Video Settings > Shader Packs",
_ => "Options > Resource Packs",
};
Ok(format!(
"Installed {}, checksums checked. Turn it on in the game: {turn_on}.",
names.join(", ")
))
});
let _ = tx.send(Event::Done(result, modpack));
});
}
fn mods_field(&mut self, cx: &mut Context<Self>) -> Stateful<Div> {
let t = self.theme;
let m = &self.mods;
let focused = m.focused;
let shown: String = {
let chars: Vec<char> = m.text.chars().collect();
chars[chars.len().saturating_sub(40)..].iter().collect()
};
div()
.id("mods-search")
.track_focus(&m.focus)
.flex()
.items_center()
.w(px(320.))
.h(px(theme::FIELD))
.px(px(12.))
.overflow_hidden()
.rounded(px(theme::RADIUS))
.border_1()
.border_color(if focused { t.accent } else { t.rule })
.bg(t.surface)
.text_size(px(theme::UI.px))
.cursor_text()
.child(if m.text.is_empty() && !focused {
div().text_color(t.muted).child("Search, then Enter")
} else {
div().text_color(t.ink).child(shown)
})
.when(focused, |d| {
d.child(div().flex_none().w(px(1.)).h(px(16.)).bg(t.ink))
})
.on_click(cx.listener(|this, _: &ClickEvent, window, cx| {
window.focus(&this.mods.focus);
cx.notify();
}))
.on_key_down(cx.listener(|this, ev: &KeyDownEvent, window, cx| {
let k = &ev.keystroke;
let command = k.modifiers.control || k.modifiers.platform;
match type_key(
&mut this.mods.text,
false,
&k.key,
k.key_char.as_deref(),
command,
) {
Key::Enter => this.mods_search(0),
Key::Escape => window.blur(),
Key::Paste => {
if let Some(text) = cx.read_from_clipboard().and_then(|c| c.text()) {
let line = text.lines().next().unwrap_or_default().trim().to_string();
this.mods.text.push_str(&line);
}
}
Key::Edited => {}
Key::Pass => return,
}
if let Some((at, _)) = this.mods.text.char_indices().nth(100) {
this.mods.text.truncate(at);
}
cx.stop_propagation();
cx.notify();
}))
}
pub(super) fn mods_page(&mut self, cx: &mut Context<Self>) -> Div {
let t = self.theme;
if !self.mods.loaded {
self.mods.loaded = true;
self.mods.installed = installed::Installed::load(&backend::game_home()).entries;
self.mods_check_updates();
self.mods_search(0);
}
let header = page_header(
"Mods",
"Resource packs, shader packs and modpacks that Horizon loads. Each file is checked \
against its source's checksum before it reaches your game folder.",
&t,
);
let this = cx.entity().downgrade();
let kinds = segments("mods-kind", &KINDS, self.mods.kind, &t, {
let this = this.clone();
move |kind, _, cx| {
let _ = this.update(cx, |this, cx| {
if this.mods.kind != kind {
this.mods.kind = kind;
this.mods_search(0);
}
cx.notify();
});
}
});
let everything = self.mods.everything;
let toggle = div()
.id("mods-everything")
.flex()
.items_center()
.gap(px(8.))
.cursor_pointer()
.child(switch("mods-everything-switch", everything, &t))
.child(
text(theme::LABEL)
.text_color(t.ink_soft)
.child("Show everything"),
)
.on_click(cx.listener(|this, _: &ClickEvent, _, cx| {
this.mods.everything = !this.mods.everything;
this.mods_search(0);
cx.notify();
}));
let source_note = if self.mods.curseforge {
segments("mods-source", &SOURCES, self.mods.source, &t, {
let this = this.clone();
move |source, _, cx| {
let _ = this.update(cx, |this, cx| {
if this.mods.source != source {
this.mods.source = source;
this.mods_search(0);
}
cx.notify();
});
}
})
.into_any_element()
} else {
text(theme::CAPTION)
.text_color(t.muted)
.child("From Modrinth. CurseForge comes once the launcher has its API key.")
.into_any_element()
};
let controls = div()
.flex()
.flex_col()
.gap(px(12.))
.child(
div()
.flex()
.flex_wrap()
.items_center()
.gap(px(12.))
.child(kinds)
.child(self.mods_field(cx))
.child(toggle),
)
.child(source_note);
let mut page = div()
.flex()
.flex_col()
.gap(px(32.))
.child(header)
.child(controls);
if let Some((_, line, f)) = &self.mods.busy {
page = page.child(
plate(&t)
.flex()
.flex_col()
.gap(px(8.))
.p(px(16.))
.child(caps("Installing").text_color(t.accent))
.child(
text(theme::CAPTION)
.font_family(theme::MONO)
.text_color(t.ink_soft)
.truncate()
.child(format!("{line} {:.0}%", f * 100.)),
),
);
}
match &self.mods.message {
Some(Ok(done)) => {
page = page.child(
plate(&t)
.p(px(16.))
.text_size(px(theme::UI.px))
.text_color(t.ink)
.child(done.clone()),
)
}
Some(Err(e)) => page = page.child(notice(e.clone(), &t)),
None => {}
}
if let Some(list) = self.mods_installed_list(cx) {
page = page.child(list);
}
page.child(self.mods_results(cx))
}
fn mods_installed_list(&self, cx: &mut Context<Self>) -> Option<Div> {
let t = self.theme;
let kind = self.mods.kind;
let entries: Vec<&installed::Entry> = self
.mods
.installed
.iter()
.filter(|e| e.kind == kind)
.collect();
if entries.is_empty() {
return None;
}
let busy = self.mods.busy.is_some();
let mut list = div().flex().flex_col().border_t_1().border_color(t.rule);
for (i, e) in entries.into_iter().enumerate() {
let key = (e.source, e.project.clone());
let mut right = div().flex().items_center().gap(px(8.));
if let Some(number) = self.mods.updates.get(&key) {
let mut update = button(
SharedString::from(format!("mods-update-{}", e.project)),
format!("Update to {number}"),
Kind::Secondary,
&t,
);
if busy {
update = disabled(update);
} else {
let (source, id) = key.clone();
update = update.on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
this.mods_install(source, id.clone(), None);
cx.notify();
}));
}
right = right.child(update);
}
let confirming = self.mods.confirm_remove.as_deref() == Some(e.project.as_str());
let id = e.project.clone();
let remove = button(
SharedString::from(format!("mods-remove-{}", e.project)),
if confirming {
"Remove for good"
} else {
"Remove"
},
if confirming {
Kind::Secondary
} else {
Kind::Ghost
},
&t,
)
.when(confirming, |b| b.text_color(t.danger))
.on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
if this.mods.confirm_remove.as_ref() == Some(&id) {
let home = backend::game_home();
this.mods.message = Some(
installed::remove(&home, &id).map(|e| format!("Removed {}.", e.title)),
);
this.mods.installed = installed::Installed::load(&home).entries;
this.mods.confirm_remove = None;
} else {
this.mods.confirm_remove = Some(id.clone());
}
cx.notify();
}));
right = right.child(remove);
let detail = div()
.flex()
.flex_col()
.child(format!(
"{} · from {}{} · {}",
e.number,
e.source.label(),
if e.dependency {
", needed by another pack"
} else {
""
},
e.file
))
.child(
div()
.font_family(theme::MONO)
.child(format!("checked: {}", short_sum(&e.checksum))),
);
list = list.child(index_row(
i + 1,
e.title.clone(),
Some(detail.into_any_element()),
Some(right.into_any_element()),
&t,
));
}
Some(
div()
.flex()
.flex_col()
.gap(px(12.))
.child(caps("Installed").text_color(t.muted))
.child(list),
)
}
fn mods_results(&self, cx: &mut Context<Self>) -> Div {
let t = self.theme;
let m = &self.mods;
if let Some(e) = &m.error {
return div().child(notice(e.clone(), &t));
}
if m.results.is_empty() {
let line = if m.searching || !m.searched {
"Searching…"
} else if m.everything {
"Nothing found."
} else {
"Nothing found that runs in Horizon. Show everything lists the rest."
};
return centered(line, &t);
}
let busy = m.busy.as_ref().map(|b| b.0.as_str());
let mut list = div().flex().flex_col().border_t_1().border_color(t.rule);
for (i, p) in m.results.iter().enumerate() {
let support = p.support();
let color = match support {
Support::Works => t.success,
Support::Partial(_) => t.accent,
Support::No(_) => t.muted,
};
let mut right = div()
.flex()
.items_center()
.gap(px(8.))
.child(caps(support.label()).flex_none().text_color(color));
let page_url = p.page.clone();
if !page_url.is_empty() {
right = right.child(
button(
SharedString::from(format!("mods-page-{}", p.id)),
"Page",
Kind::Ghost,
&t,
)
.on_click(move |_, _, cx| cx.open_url(&page_url)),
);
}
if busy == Some(p.id.as_str()) {
right = right.child(caps("Installing").text_color(t.accent));
} else if m.entry(p).is_some() {
right = right.child(caps("Installed").text_color(t.muted));
} else if support.installable() {
let label = if p.kind == PackKind::Modpack {
"Import"
} else {
"Install"
};
let mut install = button(
SharedString::from(format!("mods-install-{}", p.id)),
label,
Kind::Secondary,
&t,
);
if busy.is_some() {
install = disabled(install);
} else {
let p = p.clone();
install = install.on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
this.mods_install(p.source, p.id.clone(), Some(p.clone()));
cx.notify();
}));
}
right = right.child(install);
}
let mut by = Vec::new();
if !p.author.is_empty() {
by.push(format!("by {}", p.author));
}
by.push(format!("{} downloads", count(p.downloads)));
by.push(format!("from {}", p.source.label()));
if !p.license.is_empty() {
by.push(p.license.clone());
}
let detail = div()
.flex()
.flex_col()
.child(div().truncate().child(p.summary.clone()))
.child(by.join(" · "))
.children(
support
.reason()
.map(|r| div().text_color(t.ink_soft).child(r.to_string())),
);
list = list.child(index_row(
i + 1,
p.title.clone(),
Some(detail.into_any_element()),
Some(right.into_any_element()),
&t,
));
}
let mut out = div().flex().flex_col().child(list);
if m.more {
let mut more = button("mods-more", "More", Kind::Ghost, &t);
if m.searching {
more = disabled(more);
} else {
let offset = m.results.len();
more = more.on_click(cx.listener(move |this, _: &ClickEvent, _, cx| {
this.mods_search(offset);
cx.notify();
}));
}
out = out.child(div().flex().pt(px(16.)).child(more));
}
out
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn counts_and_checksums_read_short() {
assert_eq!(count(999), "999");
assert_eq!(count(1_500), "1.5k");
assert_eq!(count(51_404_735), "51.4M");
let sum = format!("SHA-512:{}", "ab".repeat(64));
assert_eq!(short_sum(&sum), "SHA-512 abababababab…abababab");
assert_eq!(short_sum("SHA-1:abcd"), "SHA-1:abcd");
}
}
+2 -2
View File
@@ -291,7 +291,7 @@ fn bytes(n: u64) -> String {
/// A backup's date and kind from its name (`2026-10-19_11-28-57-manual.zip`, UTC), for people.
/// What a key did in a one-line field.
#[derive(Debug, PartialEq)]
enum Key {
pub(super) enum Key {
Enter,
Escape,
/// Command/Ctrl-V: the caller pastes the clipboard's first line.
@@ -303,7 +303,7 @@ enum Key {
/// Types `key` into `text`. A `selected` suggestion is replaced by what's typed or pasted, and
/// cleared by Backspace.
fn type_key(
pub(super) fn type_key(
text: &mut String,
selected: bool,
key: &str,