mirror of
https://github.com/narrrl/proton-stream.git
synced 2026-11-18 18:15:03 +01:00
With AniList chosen, a title AniList has no match for is now searched on TVmaze, keyless, before it is given up on. One provider for the whole library left live-action shows in a share of anime unmatched, and switching to TMDB would have dropped every AniList match, chain and shelf. The service holds a chain of providers. A match is stored under the provider that gave it, and enrichment and refreshes go to that provider; a miss is stored under the last provider asked, and is_fresh only trusts a miss from the end of the chain, so AniList misses stored before this are asked again at once. A provider failure still ends the lookup instead of falling through. The hand matcher searches every provider in the chain and labels each result with its source. TVmaze is never offered in the settings and is not asked about titles known to be films.
305 lines
12 KiB
Rust
305 lines
12 KiB
Rust
//! Picking a title's provider entry by hand.
|
|
//!
|
|
//! The matcher is deliberately unwilling to guess — see
|
|
//! [`pstr_meta::matching::MATCH_FLOOR`], and the reasoning that a wrong poster
|
|
//! does not look like a bug but like the library being wrong. The cost of that
|
|
//! is a handful of titles it will not decide about, and this dialog is where
|
|
//! they get decided: the provider's own answers, unscored and in its own order,
|
|
//! and a click that pins one of them.
|
|
//!
|
|
//! Nothing here scores anything. A person reading a list of eight entries with
|
|
//! their posters next to them is not guessing, which is exactly why the floor
|
|
//! that stops the scorer should not also stop them.
|
|
|
|
use pstr_core::metadata::{ProviderId, TitleMetadata};
|
|
|
|
use crate::app::{Action, Matcher};
|
|
use crate::theme;
|
|
use crate::ui::{self, Art};
|
|
|
|
/// How tall the result list may get before it scrolls. Enough for four rows,
|
|
/// which is what a page of provider answers usually needs.
|
|
const RESULTS_HEIGHT: f32 = 340.0;
|
|
|
|
/// A result row's poster, at the shape a cover image actually is.
|
|
const THUMB: egui::Vec2 = egui::vec2(46.0, 69.0);
|
|
|
|
pub fn show(
|
|
ctx: &egui::Context,
|
|
matcher: &mut Matcher,
|
|
art: &mut Art<'_>,
|
|
provider: ProviderId,
|
|
actions: &mut Vec<Action>,
|
|
) {
|
|
// What the title is matched to now, cloned out before `art` is borrowed for
|
|
// the rows below.
|
|
let current = art
|
|
.metadata
|
|
.get(&matcher.title_key)
|
|
.map(|record| (record.metadata.clone(), record.manual));
|
|
|
|
let modal = egui::Modal::new(egui::Id::new("matcher"))
|
|
.frame(
|
|
egui::Frame::new()
|
|
.fill(theme::surface())
|
|
.inner_margin(egui::Margin::same(18))
|
|
.corner_radius(egui::CornerRadius::same(theme::radius::LG)),
|
|
)
|
|
.show(ctx, |ui| {
|
|
ui.set_width(620.0);
|
|
|
|
ui.label(
|
|
theme::Role::Heading
|
|
.rich(format!("Match “{}”", matcher.title_name))
|
|
.strong()
|
|
.color(theme::text()),
|
|
);
|
|
ui.label(ui::muted(format!(
|
|
"Everything {} answer with, in their own order — nothing is scored here.",
|
|
pstr_meta::service::chain_label(provider)
|
|
)));
|
|
ui.add_space(theme::space::L);
|
|
|
|
search_row(ui, matcher, actions);
|
|
ui.add_space(theme::space::S);
|
|
current_row(ui, matcher, current.as_ref(), actions);
|
|
ui.add_space(theme::space::L);
|
|
|
|
if let Some(error) = &matcher.error {
|
|
ui.label(theme::Role::Caption.rich(error).color(theme::danger()));
|
|
ui.add_space(theme::space::S);
|
|
}
|
|
|
|
results(ui, matcher, art, actions);
|
|
|
|
ui.add_space(theme::space::L);
|
|
ui.horizontal(|ui| {
|
|
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
|
|
if ui.button("Close").clicked() {
|
|
actions.push(Action::CloseMatcher);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
// Escape, a click on the backdrop, or the close button above: all of them
|
|
// mean the same thing, and the dialog changes nothing until a row is
|
|
// clicked, so leaving it needs no confirmation.
|
|
if modal.should_close() {
|
|
actions.push(Action::CloseMatcher);
|
|
}
|
|
}
|
|
|
|
/// The box and the button. Enter searches, because a search box that ignores it
|
|
/// is a search box people think is broken.
|
|
fn search_row(ui: &mut egui::Ui, matcher: &mut Matcher, actions: &mut Vec<Action>) {
|
|
ui.horizontal(|ui| {
|
|
let box_width = ui.available_width() - 90.0;
|
|
let field = ui.add(
|
|
egui::TextEdit::singleline(&mut matcher.query)
|
|
.hint_text("Title to search for")
|
|
.desired_width(box_width.max(120.0)),
|
|
);
|
|
if std::mem::take(&mut matcher.focus) {
|
|
field.request_focus();
|
|
}
|
|
|
|
let entered = field.lost_focus() && ui.input(|input| input.key_pressed(egui::Key::Enter));
|
|
if matcher.searching {
|
|
ui.add(egui::Spinner::new().size(16.0));
|
|
} else if (ui.button("Search").clicked() || entered) && !matcher.query.trim().is_empty() {
|
|
actions.push(Action::SearchMatches);
|
|
}
|
|
});
|
|
}
|
|
|
|
/// What the title is matched to now, and the way back to no match at all.
|
|
fn current_row(
|
|
ui: &mut egui::Ui,
|
|
matcher: &Matcher,
|
|
current: Option<&(Option<TitleMetadata>, bool)>,
|
|
actions: &mut Vec<Action>,
|
|
) {
|
|
ui.horizontal(|ui| {
|
|
match current {
|
|
Some((Some(found), manual)) => {
|
|
ui.label(ui::muted(format!(
|
|
"Currently {}{}",
|
|
found.name,
|
|
if *manual { ", chosen by hand" } else { "" }
|
|
)));
|
|
// Only worth offering when there is something to undo: with no
|
|
// row stored, "clear" would delete nothing.
|
|
//
|
|
// A match chosen by hand is asked about first: it is work the
|
|
// next match run does not redo.
|
|
let asking = ui.id().with(("forget", &matcher.title_key));
|
|
if ui.data(|data| data.get_temp::<bool>(asking).unwrap_or(false)) {
|
|
ui.label(ui::muted("Forget the match you chose?"));
|
|
if ui::danger_button(ui, "Forget").clicked() {
|
|
ui.data_mut(|data| data.remove::<bool>(asking));
|
|
actions.push(Action::ForgetMatch(matcher.title_key.clone()));
|
|
}
|
|
if ui.button("Keep").clicked() {
|
|
ui.data_mut(|data| data.remove::<bool>(asking));
|
|
}
|
|
} else if ui
|
|
.button("Clear")
|
|
.on_hover_text("Forget this match and let the next match run decide again")
|
|
.clicked()
|
|
{
|
|
if *manual {
|
|
ui.data_mut(|data| data.insert_temp(asking, true));
|
|
} else {
|
|
actions.push(Action::ForgetMatch(matcher.title_key.clone()));
|
|
}
|
|
}
|
|
}
|
|
Some((None, _)) => {
|
|
ui.label(ui::muted("Currently unmatched — the provider had nothing."));
|
|
if ui
|
|
.button("Clear")
|
|
.on_hover_text("Forget the stored miss so this title is asked about again")
|
|
.clicked()
|
|
{
|
|
actions.push(Action::ForgetMatch(matcher.title_key.clone()));
|
|
}
|
|
}
|
|
None => {
|
|
ui.label(ui::muted("Not matched yet."));
|
|
}
|
|
};
|
|
});
|
|
}
|
|
|
|
/// The provider's answers, one clickable row each.
|
|
fn results(ui: &mut egui::Ui, matcher: &Matcher, art: &mut Art<'_>, actions: &mut Vec<Action>) {
|
|
if matcher.results.is_empty() {
|
|
ui.label(ui::muted(if matcher.searching {
|
|
"Searching…"
|
|
} else if matcher.asked {
|
|
// Both providers match on whole words, so a name the index has never
|
|
// seen empties the page rather than returning something near it.
|
|
"Nothing came back. Try a shorter name, or the title in another language."
|
|
} else {
|
|
"Search to see what the provider has."
|
|
}));
|
|
return;
|
|
}
|
|
|
|
egui::ScrollArea::vertical()
|
|
.max_height(RESULTS_HEIGHT)
|
|
.auto_shrink([false, true])
|
|
.show(ui, |ui| {
|
|
for found in &matcher.results {
|
|
if row(ui, art, found).clicked() {
|
|
actions.push(Action::ChooseMatch(Box::new(found.clone())));
|
|
}
|
|
ui.add_space(theme::space::XS);
|
|
}
|
|
});
|
|
}
|
|
|
|
/// One answer: its cover, its names, and enough of its synopsis to tell two
|
|
/// entries in the same franchise apart — which is the whole job of this list.
|
|
fn row(ui: &mut egui::Ui, art: &mut Art<'_>, found: &TitleMetadata) -> egui::Response {
|
|
let response = egui::Frame::new()
|
|
.fill(theme::card())
|
|
.corner_radius(egui::CornerRadius::same(theme::radius::SM))
|
|
.inner_margin(egui::Margin::same(8))
|
|
.show(ui, |ui| {
|
|
ui.set_width(ui.available_width());
|
|
ui.horizontal_top(|ui| {
|
|
let (rect, _) = ui.allocate_exact_size(THUMB, egui::Sense::hover());
|
|
if let Some(texture) = poster(art, found) {
|
|
ui.painter().image(
|
|
texture.id(),
|
|
rect,
|
|
egui::Rect::from_min_max(egui::pos2(0.0, 0.0), egui::pos2(1.0, 1.0)),
|
|
egui::Color32::WHITE,
|
|
);
|
|
} else {
|
|
ui.painter().rect_filled(
|
|
rect,
|
|
egui::CornerRadius::same(theme::radius::BADGE),
|
|
theme::card_hover(),
|
|
);
|
|
}
|
|
|
|
ui.add_space(theme::space::L);
|
|
ui.vertical(|ui| {
|
|
ui.label(
|
|
theme::Role::Body
|
|
.rich(&found.name)
|
|
.strong()
|
|
.color(theme::text()),
|
|
);
|
|
if let Some(original) = &found.original_name {
|
|
ui.label(ui::muted(original.clone()));
|
|
}
|
|
ui.label(ui::muted(facts(found)));
|
|
if let Some(overview) = &found.overview {
|
|
let mut job = egui::text::LayoutJob::simple(
|
|
overview.replace('\n', " "),
|
|
theme::Role::Caption.font(),
|
|
theme::muted(),
|
|
ui.available_width(),
|
|
);
|
|
job.wrap.max_rows = 2;
|
|
job.wrap.overflow_character = Some('…');
|
|
ui.label(job);
|
|
}
|
|
});
|
|
});
|
|
})
|
|
.response;
|
|
|
|
let response = response.interact(egui::Sense::click());
|
|
if response.hovered() {
|
|
ui.painter().rect_stroke(
|
|
response.rect,
|
|
egui::CornerRadius::same(theme::radius::SM),
|
|
egui::Stroke::new(1.5, theme::accent()),
|
|
egui::StrokeKind::Inside,
|
|
);
|
|
}
|
|
response.on_hover_cursor(egui::CursorIcon::PointingHand)
|
|
}
|
|
|
|
/// The cover for one answer, cached under the provider's id for it rather than
|
|
/// under a title key — these are not any title's artwork until one is picked.
|
|
fn poster(art: &mut Art<'_>, found: &TitleMetadata) -> Option<egui::TextureHandle> {
|
|
let url = found
|
|
.poster_url
|
|
.clone()
|
|
.or_else(|| found.backdrop_url.clone())?;
|
|
let key = format!("option:{}:{}", found.provider.as_str(), found.remote_id);
|
|
let engine = art.engine;
|
|
art.posters
|
|
.texture(&key, || engine.request_poster(key.clone(), url))
|
|
}
|
|
|
|
/// `Film · 2017 · 26 episodes · ★ 8.2 · AniList`, with whatever the provider
|
|
/// left out simply absent. The provider last, because one search asks more
|
|
/// than one, and the same show can come back from each.
|
|
fn facts(found: &TitleMetadata) -> String {
|
|
let mut parts: Vec<String> = vec![
|
|
match found.kind {
|
|
pstr_core::library::TitleKind::Series => "Series",
|
|
pstr_core::library::TitleKind::Film => "Film",
|
|
}
|
|
.to_string(),
|
|
];
|
|
if let Some(year) = found.year {
|
|
parts.push(year.to_string());
|
|
}
|
|
if let Some(episodes) = found.episodes {
|
|
parts.push(ui::library::plural(episodes as usize, "episode"));
|
|
}
|
|
if let Some(rating) = found.rating {
|
|
parts.push(format!("{} {rating:.1}", egui_phosphor::regular::STAR));
|
|
}
|
|
parts.push(found.provider.label().to_string());
|
|
parts.join(" · ")
|
|
}
|