Terminal interface to find, download, and stream movies, TV shows, and live TV using local media players.
use super::App;
use crate::tui::{
action::Action,
overlay::NotificationKind,
state::{BrowsePreset, DetailsPane, InputMode, Screen},
};
use ratatui::layout::{Constraint, Layout, Rect};
impl App {
pub(super) fn handle_mouse(&mut self, col: u16, row: u16) -> Option<Action> {
let (cols, rows) = crossterm::terminal::size().unwrap_or((80, 24));
let cols = if cols == 0 { 80 } else { cols };
let rows = if rows == 0 { 24 } else { rows };
let area = Rect::new(0, 0, cols, rows);
if self.handle_overlay_mouse(col, row, area) {
return None;
}
let main_area = if self.state.download_progress.is_some() {
crate::tui::app::App::split_main_and_download(area)[0]
} else {
area
};
match self.state.active_screen {
Screen::Home => self.handle_home_mouse(col, row, main_area),
Screen::Details => self.handle_details_mouse(col, row, main_area),
}
}
fn handle_overlay_mouse(&mut self, col: u16, row: u16, area: Rect) -> bool {
if self.state.is_updating {
return true;
}
if !self.state.notifications.is_empty() {
let rects = crate::tui::overlay::notification_rects(
area,
&self.state.notifications,
self.state.basic_terminal,
self.state.download_progress.is_some(),
);
for (idx, rect) in rects {
if rect.contains(ratatui::layout::Position::new(col, row)) {
self.state.notifications.remove(idx);
return true;
}
}
}
if self.state.download_progress.is_some() {
let [_, dl_area] = crate::tui::app::App::split_main_and_download(area);
if dl_area.contains(ratatui::layout::Position::new(col, row)) {
let cancel_rect = Rect {
x: dl_area.right().saturating_sub(14),
y: dl_area.y,
width: 14.min(dl_area.width),
height: 1,
};
if cancel_rect.contains(ratatui::layout::Position::new(col, row)) {
self.action_sender.send(Action::CancelDownload).ok();
}
return true;
}
}
if self.state.player_picker_popup {
let items = self
.state
.available_players
.iter()
.map(|k| k.label().to_string())
.collect::<Vec<_>>();
let confirm_label = if self.state.settings_player_picker {
"Select"
} else {
"Play"
};
let layout = if self.state.settings_player_picker {
crate::tui::overlay::settings_picker_layout(
area,
self.state.settings_category,
&items,
10,
)
} else {
crate::tui::overlay::picker_layout(area, &items, confirm_label, 10)
};
match click_in_picker(
layout,
col,
row,
&self.state.player_picker_state,
items.len(),
area,
) {
Some(Some(clicked_idx)) => {
self.state.player_picker_state.select(Some(clicked_idx));
self.action_sender.send(Action::Submit).ok();
}
Some(None) => {}
None => {
self.state.is_resolving_playback = false;
self.state.player_picker_popup = false;
self.state.settings_player_picker = false;
}
}
return true;
}
if self.state.show_sources_popup {
let items = crate::providers::models::ProviderKind::ENABLED
.iter()
.map(|p| format!(" [✓] {} ", p.label()))
.collect::<Vec<_>>();
let layout = crate::tui::overlay::settings_picker_layout(
area,
self.state.settings_category,
&items,
20,
);
match click_in_picker(
layout,
col,
row,
&self.state.sources_list_state,
items.len(),
area,
) {
Some(Some(clicked_idx)) => {
self.state.sources_list_state.select(Some(clicked_idx));
if let Some(&provider) =
crate::providers::models::ProviderKind::ENABLED.get(clicked_idx)
{
self.action_sender
.send(Action::ToggleProvider(provider))
.ok();
}
}
Some(None) => {}
None => {
self.state.show_sources_popup = false;
}
}
return true;
}
if self.state.show_theme_popup {
let theme_names = crate::tui::theme::AVAILABLE_THEMES;
let longest_name = theme_names
.iter()
.map(|name| crate::tui::text::width(name))
.max()
.unwrap_or(10);
let items: Vec<String> = theme_names
.iter()
.map(|name| {
if self.state.basic_terminal {
format!(" {name:<pad$} * * * ", pad = longest_name)
} else {
format!(" {name:<pad$} ■ ■ ■ ", pad = longest_name)
}
})
.collect();
let layout = if self.state.show_settings_popup {
crate::tui::overlay::settings_picker_layout(
area,
self.state.settings_category,
&items,
16,
)
} else {
crate::tui::overlay::picker_layout(area, &items, "Apply", 16)
};
match click_in_picker(
layout,
col,
row,
&self.state.theme_list_state,
items.len(),
area,
) {
Some(Some(clicked_idx)) => {
self.state.theme_list_state.select(Some(clicked_idx));
if let Some(&theme_name) = theme_names.get(clicked_idx) {
self.action_sender
.send(Action::SelectTheme(theme_name.to_string()))
.ok();
self.state.show_theme_popup = false;
self.state.theme_list_state.select(None);
self.state
.set_status_default(format!("{theme_name} theme applied."));
}
}
Some(None) => {}
None => {
if let Some(orig) = self.state.original_theme_kind.take() {
self.action_sender.send(Action::SelectTheme(orig)).ok();
}
self.state.show_theme_popup = false;
self.state.theme_list_state.select(None);
}
}
return true;
}
if self.state.show_settings_popup {
let popup =
crate::tui::overlay::settings_modal_layout(area, self.state.settings_category);
if !popup.contains(ratatui::layout::Position::new(col, row)) {
self.state.show_settings_popup = false;
self.state.settings_download_dir_input = None;
self.persist_config();
return true;
}
if let Some(cat) = crate::tui::widgets::settings::settings_category_tab_at(
popup,
col,
row,
self.state.basic_terminal,
self.state.settings_category,
) {
self.state.settings_select_category(cat);
return true;
}
if let Some(clicked_row) = crate::tui::widgets::settings::settings_row_at(
popup,
self.state.settings_category,
col,
row,
) {
self.state.settings_selected_row = clicked_row;
self.action_sender.send(Action::SettingsActivateRow).ok();
return true;
}
return true;
}
if self.state.show_browse_popup {
let is_addon =
self.state.active_provider == crate::providers::models::ProviderKind::Addons;
let raw_labels: Vec<String> = if is_addon {
crate::providers::addons::models::curated_catalog_presets(
&self.state.installed_addons,
)
.into_iter()
.map(|target| target.label)
.collect()
} else {
BrowsePreset::ALL
.iter()
.map(|preset| preset.label().to_string())
.collect()
};
let browse_items: Vec<String> = raw_labels
.iter()
.map(|label| {
let badge_str = if label.to_ascii_lowercase().contains("movie")
|| label.to_ascii_lowercase().contains("top rated (all-time)")
|| label.to_ascii_lowercase().contains("top rated (recent")
{
"[MOVIES] "
} else if label.to_ascii_lowercase().contains("series")
|| label.to_ascii_lowercase().contains("airing")
|| label.to_ascii_lowercase().contains("show")
|| label.to_ascii_lowercase().contains("tv")
{
"[SERIES] "
} else {
"[DISCOVER] "
};
format!(" {badge_str}{label} ")
})
.collect();
let layout = crate::tui::overlay::browse_picker_layout(area, &browse_items, 36);
match click_in_picker(
layout,
col,
row,
&self.state.browse_list_state,
browse_items.len(),
area,
) {
Some(Some(clicked_idx)) => {
self.state.browse_list_state.select(Some(clicked_idx));
self.state.show_browse_popup = false;
self.state.browse_list_state.select(None);
if is_addon {
let targets = crate::providers::addons::models::curated_catalog_presets(
&self.state.installed_addons,
);
if let Some(target) = targets.get(clicked_idx).cloned() {
self.action_sender
.send(Action::SelectAddonCatalog(target))
.ok();
}
} else if let Some(preset) = BrowsePreset::ALL.get(clicked_idx).copied() {
self.action_sender.send(Action::SelectBrowse(preset)).ok();
}
}
Some(None) => {}
None => {
self.state.show_browse_popup = false;
self.state.browse_list_state.select(None);
}
}
return true;
}
if self.state.show_help {
self.state.show_help = false;
return true;
}
if self.state.input_mode != InputMode::Editing
&& let Some((ver, notes)) = &self.state.update_available
{
let layout = crate::tui::overlay::update_modal_layout(area, notes);
if layout
.popup_area
.contains(ratatui::layout::Position::new(col, row))
{
let env = std::env::current_exe()
.as_deref()
.map(crate::updater::apply::detect_environment)
.unwrap_or(crate::updater::apply::InstallationEnvironment::DirectReplace);
if row == layout.button_row_y {
if col < layout.update_btn_end_x {
match env {
crate::updater::apply::InstallationEnvironment::Homebrew => {
self.state.notify(
NotificationKind::Info,
"Homebrew Update",
"Installed via Homebrew.",
);
}
crate::updater::apply::InstallationEnvironment::Scoop => {
self.state.notify(
NotificationKind::Info,
"Scoop Update",
"Installed via Scoop.",
);
}
crate::updater::apply::InstallationEnvironment::DirectReplace
| crate::updater::apply::InstallationEnvironment::WindowsHelper => {
self.action_sender.send(Action::StartSelfUpdate).ok();
}
_ => {}
}
} else if col < layout.open_btn_end_x {
let url = crate::updater::check::release_tag_url(ver);
let _ = crate::net::open_external_url(&url);
}
self.state.update_available = None;
}
} else {
self.state.update_available = None;
}
return true;
}
if self.state.subtitle_popup || self.state.is_download_subtitle_popup {
let items = self
.state
.subtitle_list
.iter()
.map(|(name, _)| crate::tui::text::format_subtitle_label(name))
.collect::<Vec<_>>();
let confirm_label = if self.state.is_download_subtitle_popup {
"Download"
} else {
"Use"
};
match click_in_picker(
crate::tui::overlay::picker_layout(area, &items, confirm_label, 20),
col,
row,
&self.state.subtitle_list_state,
items.len(),
area,
) {
Some(Some(clicked_idx)) => {
self.state.subtitle_list_state.select(Some(clicked_idx));
self.action_sender.send(Action::Submit).ok();
}
Some(None) => {}
None => {
let is_dl = self.state.is_download_subtitle_popup;
self.state.is_resolving_playback = false;
self.state.subtitle_popup = false;
self.state.is_download_subtitle_popup = false;
self.state.pending_play_link = None;
self.state.pending_playback_source = None;
self.state.subtitle_list.clear();
self.state.subtitle_list_state.select(None);
if is_dl {
self.state.is_waiting_for_download_stream = false;
self.state.download_queue.clear();
self.state.download_queue_total = 0;
self.state.season_subtitle_preference = None;
self.state
.set_status_default("Download subtitle selection cancelled.");
} else {
self.state.notify(
crate::tui::overlay::NotificationKind::Info,
"Playback Cancelled",
"Stream launch cancelled.",
);
}
}
}
return true;
}
if self.state.show_overview_modal {
let (popup, _) = crate::tui::overlay::overview_modal_layout(
area,
&self.state.overview_modal_content,
);
if !popup.contains(ratatui::layout::Position::new(col, row)) {
self.state.close_overview_modal();
}
return true;
}
if self.state.tv_config_popup {
let rows = self.state.tv_manager_rows();
let total_rows = rows.len();
let longest_source_width = self
.state
.tv_playlists
.iter()
.map(|source| crate::tui::text::width(source))
.max()
.unwrap_or(28);
let popup = crate::tui::overlay::tv_config_layout(
area,
longest_source_width,
total_rows,
self.state.tv_input_active,
);
if popup.contains(ratatui::layout::Position::new(col, row)) {
if !self.state.tv_input_active {
let item_start_y = popup.y + 1;
if row >= item_start_y && (row - item_start_y) < total_rows as u16 {
let clicked_idx = (row - item_start_y) as usize;
self.state.tv_manager_selected = clicked_idx;
if let Some(r) = rows.get(clicked_idx) {
match r {
crate::tui::state::TvManagerRow::AddPlaylist => {
self.action_sender.send(Action::TvInputToggle(false)).ok();
}
crate::tui::state::TvManagerRow::Playlist(_) => {}
}
}
}
}
} else {
self.state.tv_config_popup = false;
self.state.tv_input_active = false;
}
return true;
}
if self.state.addon_manager_popup {
let addons_count = self.state.installed_addons.len();
let popup = crate::tui::overlay::addon_manager_layout(
area,
addons_count,
self.state.max_addon_name_width(),
self.state.addon_input_active,
);
if popup.contains(ratatui::layout::Position::new(col, row)) {
if !self.state.addon_input_active {
let items_start_y = popup.y + 1;
let total_items = addons_count + 1;
if row >= items_start_y && row < items_start_y + total_items as u16 {
let clicked_idx = (row - items_start_y) as usize;
if clicked_idx < total_items {
self.state.addon_manager_selected = clicked_idx;
self.addon_manager_activate();
}
}
}
} else {
self.state.addon_manager_popup = false;
self.state.addon_input_active = false;
}
return true;
}
false
}
fn handle_home_mouse(&mut self, col: u16, row: u16, area: Rect) -> Option<Action> {
if self.state.is_loading && self.state.search_results.is_empty() {
return None;
}
let is_landing = self.state.search_results.is_empty()
&& (self.state.search_query.trim().is_empty()
|| self.state.input_mode == InputMode::Editing);
let landing_layout = if is_landing {
Some(crate::tui::screens::home::landing_split(
area,
self.state.is_tv_mode,
self.state.basic_terminal,
self.state.landing_deck_visible(),
))
} else {
None
};
if let Some((_tier, ref rows)) = landing_layout {
let card_width = crate::tui::screens::home::search_deck_width(area, &self.state, true);
let card_x = area.x + area.width.saturating_sub(card_width) / 2;
let search_y = rows.rects[rows.search].y;
let search_card_area = Rect {
x: card_x,
y: search_y,
width: card_width,
height: rows.rects[rows.search].height,
};
if self.state.show_provider_popup {
let available = self.state.available_providers();
let (_container_area, inner_area) =
crate::tui::screens::home::provider_popup_bounds(
area,
search_card_area,
available.len(),
);
if col >= inner_area.left()
&& col < inner_area.right()
&& row >= inner_area.top()
&& row < inner_area.bottom()
{
let clicked_idx = (row - inner_area.top()) as usize;
if let Some(&provider) = available.get(clicked_idx) {
self.switch_provider(provider);
}
}
self.state.show_provider_popup = false;
self.state.provider_list_state.select(None);
return None;
}
if row == rows.rects[rows.mode_row].y {
self.handle_home_bottom_bar_click(col, area.width);
return None;
}
if self.state.input_mode == InputMode::Editing
&& !self.state.search_suggestions.is_empty()
{
let visible_count = self.state.search_suggestions.len().min(6);
let selected_index = self.state.suggest_index.unwrap_or(0);
let suggestion_offset = selected_index
.saturating_add(1)
.saturating_sub(visible_count)
.min(
self.state
.search_suggestions
.len()
.saturating_sub(visible_count),
);
let visible_slice_len = self
.state
.search_suggestions
.len()
.saturating_sub(suggestion_offset)
.min(visible_count);
let (container_area, inner_area) =
crate::tui::screens::home::search_suggestions_bounds(
area,
search_card_area,
visible_slice_len,
);
if col >= inner_area.left()
&& col < inner_area.right()
&& row >= inner_area.top()
&& row < inner_area.bottom()
{
let clicked_idx = suggestion_offset + (row - inner_area.top()) as usize;
if let Some(query) = self.state.search_suggestions.get(clicked_idx).cloned() {
self.action_sender
.send(Action::SelectSuggestion { query })
.ok();
}
return None;
}
if col >= container_area.left()
&& col < container_area.right()
&& row >= container_area.top()
&& row < container_area.bottom()
{
return None;
}
}
if col >= search_card_area.left()
&& col < search_card_area.right()
&& row >= search_card_area.top()
&& row < search_card_area.bottom()
{
let is_query_empty = self.state.search_query.is_empty();
if is_query_empty {
let pill_rect = crate::tui::screens::home::search_bar_provider_pill_rect(
search_card_area,
&self.state,
);
if col >= pill_rect.left()
&& col < pill_rect.right()
&& row >= pill_rect.top()
&& row < pill_rect.bottom()
{
if self.state.mode() == crate::tui::state::AppMode::Streaming {
let available = self.state.available_providers();
let current_idx = available
.iter()
.position(|p| *p == self.state.active_provider)
.unwrap_or(0);
self.state.show_provider_popup = true;
self.state.provider_list_state.select(Some(current_idx));
self.state.input_mode = InputMode::Normal;
} else if self.state.mode() == crate::tui::state::AppMode::Tv {
self.action_sender.send(Action::SwitchToStreamingMode).ok();
}
return None;
}
}
self.state.input_mode = InputMode::Editing;
self.state.favorites_focus = false;
self.state.favorites_landing_state.select(None);
return None;
}
if self.state.landing_deck_visible() {
let deck_y = rows.rects[rows.favorites].y;
let item_count = self.state.landing_deck_items_count() as u16;
let total_count = self.state.landing_deck_total_items_count();
let overflow = total_count.saturating_sub(item_count as usize);
let overflow_row = u16::from(overflow > 0);
let deck_height =
(item_count + overflow_row + 2).min(rows.rects[rows.favorites].height);
let deck_card_area = Rect {
x: card_x,
y: deck_y,
width: card_width,
height: deck_height,
};
if col >= deck_card_area.left()
&& col < deck_card_area.right()
&& row >= deck_card_area.top()
&& row < deck_card_area.bottom()
{
let rel_row = row - deck_card_area.top();
if rel_row == 0 {
self.state.cycle_home_deck_tab();
self.state.favorites_focus = true;
self.state.input_mode = InputMode::Normal;
} else if rel_row >= 1 && rel_row <= item_count {
let idx = (rel_row - 1) as usize;
let prev_selected = if self.state.favorites_focus {
self.state.favorites_landing_state.selected()
} else {
None
};
self.state.favorites_focus = true;
self.state.input_mode = InputMode::Normal;
self.state.favorites_landing_state.select(Some(idx));
if prev_selected == Some(idx) {
match self.state.effective_home_deck_tab() {
crate::tui::state::HomeDeckTab::ContinueWatching => {
self.action_sender
.send(Action::OpenContinueWatching(idx))
.ok();
}
crate::tui::state::HomeDeckTab::Favorites => {
self.action_sender.send(Action::OpenFavorite(idx)).ok();
}
}
}
} else if overflow > 0 && rel_row == item_count + 1 {
match self.state.effective_home_deck_tab() {
crate::tui::state::HomeDeckTab::ContinueWatching => {
self.action_sender
.send(Action::Search {
query: "/history".to_string(),
force_refresh: false,
})
.ok();
}
crate::tui::state::HomeDeckTab::Favorites => {
self.action_sender.send(Action::ShowFavorites).ok();
}
}
} else {
self.state.favorites_focus = true;
self.state.input_mode = InputMode::Normal;
}
return None;
}
} else if !self.state.is_tv_mode && area.height >= 26 {
let suggestions_open = self.state.input_mode == InputMode::Editing
&& !self.state.search_suggestions.is_empty();
if !suggestions_open {
let discover_y = rows.rects[rows.favorites].y;
let discover_height = 6;
let discover_card_area = Rect {
x: card_x,
y: discover_y,
width: card_width,
height: discover_height,
};
if col >= discover_card_area.left()
&& col < discover_card_area.right()
&& row >= discover_card_area.top()
&& row < discover_card_area.bottom()
{
if self.state.active_provider
== crate::providers::models::ProviderKind::Addons
{
self.action_sender.send(Action::ShowBrowseMenu).ok();
} else {
let rel_row = row - discover_card_area.top();
match rel_row {
1 => self
.action_sender
.send(Action::SelectBrowse(BrowsePreset::Trending))
.ok(),
2 => self
.action_sender
.send(Action::SelectBrowse(BrowsePreset::TopRatedAllTime))
.ok(),
3 => self
.action_sender
.send(Action::SelectBrowse(BrowsePreset::TopRatedRecent))
.ok(),
4 => self
.action_sender
.send(Action::SelectBrowse(BrowsePreset::MostWatched))
.ok(),
_ => self.action_sender.send(Action::ShowBrowseMenu).ok(),
};
}
return None;
}
}
}
return None;
}
let (search_bar_area, results_chunk) =
crate::tui::screens::home::search_results_layout(area);
if self.state.input_mode == InputMode::Editing && !self.state.search_suggestions.is_empty()
{
let visible_count = self.state.search_suggestions.len().min(6);
let selected_index = self.state.suggest_index.unwrap_or(0);
let suggestion_offset = selected_index
.saturating_add(1)
.saturating_sub(visible_count)
.min(
self.state
.search_suggestions
.len()
.saturating_sub(visible_count),
);
let visible_slice_len = self
.state
.search_suggestions
.len()
.saturating_sub(suggestion_offset)
.min(visible_count);
let (container_area, inner_area) = crate::tui::screens::home::search_suggestions_bounds(
area,
search_bar_area,
visible_slice_len,
);
if col >= inner_area.left()
&& col < inner_area.right()
&& row >= inner_area.top()
&& row < inner_area.bottom()
{
let clicked_idx = suggestion_offset + (row - inner_area.top()) as usize;
if let Some(query) = self.state.search_suggestions.get(clicked_idx).cloned() {
self.action_sender
.send(Action::SelectSuggestion { query })
.ok();
}
return None;
}
if col >= container_area.left()
&& col < container_area.right()
&& row >= container_area.top()
&& row < container_area.bottom()
{
return None;
}
}
if row >= search_bar_area.y && row < search_bar_area.y + search_bar_area.height {
self.state.input_mode = InputMode::Editing;
self.state.favorites_focus = false;
self.state.favorites_landing_state.select(None);
return None;
}
if row >= results_chunk.y && row < area.height {
if self.state.search_results.is_empty() {
let next_label = self.state.next_provider().label();
let ctrl_p = crate::tui::text::CTRL_P_STR;
let (btn1, btn2) = crate::tui::screens::home::no_results_button_hitboxes(
results_chunk,
next_label,
ctrl_p,
self.state.is_tv_mode,
);
let pos = ratatui::layout::Position::new(col, row);
if !self.state.is_tv_mode && btn1.contains(pos) {
self.cycle_provider();
return None;
}
if btn2.contains(pos) {
self.state.clear_search_state();
self.state.input_mode = InputMode::Normal;
self.state.set_status_default("");
return None;
}
return None;
}
if col < results_chunk.x || col >= results_chunk.right() {
return None;
}
let metrics = self
.state
.result_metrics(results_chunk.height.saturating_sub(1), results_chunk.width);
let row_height = metrics.row_height;
let clicked_relative_row = row.saturating_sub(results_chunk.y);
let visual_row = (clicked_relative_row / row_height) as usize;
let col_step = (metrics.col_width + 1).max(1);
let clicked_column = (((col.saturating_sub(results_chunk.x)) / col_step) as usize)
.min(metrics.columns.saturating_sub(1) as usize);
let page_start = self.state.result_scroll;
let target_idx = page_start + visual_row * metrics.columns as usize + clicked_column;
if target_idx < self.state.search_results.len() {
let prev_selected = self.state.search_list_state.selected();
self.state.search_list_state.select(Some(target_idx));
if prev_selected == Some(target_idx) {
self.action_sender.send(Action::Submit).ok();
} else if let Some(res) = self.state.search_results.get(target_idx) {
self.action_sender
.send(Action::FetchPreview(res.id.clone()))
.ok();
self.prefetch_visible_posters();
}
}
return None;
}
None
}
fn handle_home_bottom_bar_click(&mut self, col: u16, width: u16) {
let compact = width < 76;
let ultra_compact = width < 58;
let ctrl_s = if ultra_compact || compact {
"S"
} else {
crate::tui::text::CTRL_S_STR
};
let ctrl_t = if ultra_compact || compact {
"T"
} else {
crate::tui::text::CTRL_T_STR
};
enum BottomBtn {
Stream,
Tv,
}
let current_mode = self.state.mode();
let mut buttons: Vec<(BottomBtn, u16)> = Vec::new();
if self.state.streaming_enabled && current_mode != crate::tui::state::AppMode::Streaming {
let len = (3 + ctrl_s.len() + if compact { 0 } else { 7 }) as u16;
buttons.push((BottomBtn::Stream, len));
}
if self.state.tv_enabled && current_mode != crate::tui::state::AppMode::Tv {
let len = (3 + ctrl_t.len() + if compact { 0 } else { 3 }) as u16;
buttons.push((BottomBtn::Tv, len));
}
let mode_count = buttons.len();
let sep_len = if compact { 3 } else { 5 };
let modes_total_w: u16 = if mode_count > 0 {
buttons.iter().map(|(_, w)| *w).sum::<u16>()
+ (mode_count.saturating_sub(1) as u16) * sep_len
} else {
0
};
let util_gap = if modes_total_w > 0 {
if compact { 4 } else { 7 }
} else {
0
};
let help_w = if compact { 3 } else { 8 };
let quit_w = if compact { 3 } else { 8 };
let util_sep = if compact {
u16::from(!ultra_compact)
} else {
2
};
let total_w = modes_total_w + util_gap + help_w + util_sep + quit_w;
let start_x = width.saturating_sub(total_w) / 2;
let mut curr_x = start_x;
for (btn, w) in buttons {
if col >= curr_x && col < curr_x + w {
match btn {
BottomBtn::Stream => {
if self.state.mode() == crate::tui::state::AppMode::Streaming {
self.cycle_provider();
} else {
self.action_sender.send(Action::SwitchToStreamingMode).ok();
}
}
BottomBtn::Tv => {
if self.state.mode() != crate::tui::state::AppMode::Tv {
self.action_sender.send(Action::SwitchToTvMode).ok();
}
}
}
return;
}
curr_x += w + sep_len;
}
let help_start = start_x + modes_total_w + util_gap;
if col >= help_start && col < help_start + help_w {
self.action_sender.send(Action::ToggleHelp).ok();
return;
}
let quit_start = help_start + help_w + util_sep;
if col >= quit_start && col < quit_start + quit_w {
self.action_sender.send(Action::Quit).ok();
}
}
fn handle_details_mouse(&mut self, col: u16, row: u16, area: Rect) -> Option<Action> {
let (has_languages, is_series, dubs_count) = {
let details = self.state.selected_details.as_ref()?;
(
details.has_languages(),
details.is_series() && !self.state.available_seasons.is_empty(),
details.dubs.len(),
)
};
let mut available_panes = Vec::new();
if has_languages {
available_panes.push(DetailsPane::Languages);
}
if is_series {
available_panes.push(DetailsPane::Seasons);
available_panes.push(DetailsPane::Episodes);
}
let streams_count = self.state.selected_resources.len();
let layout = crate::tui::screens::details::details_screen_layout(
area,
self.state.selected_details.as_ref(),
);
let _tier = layout.tier;
let workflow_area = layout.workflow_area;
let bottom_area = layout.bottom_area;
let footer_area = layout.footer_area;
if row >= footer_area.y && row < footer_area.bottom() {
self.handle_details_footer_click(col, row - footer_area.y, area.width);
return None;
}
if layout.synopsis_area.height > 0
&& layout
.synopsis_area
.contains(ratatui::layout::Position::new(col, row))
{
if let Some((title, content)) = self.state.series_synopsis() {
self.state.open_overview_modal(title, content);
return None;
}
}
if workflow_area.height > 0 && row == workflow_area.y {
let details = self.state.selected_details.as_ref()?;
let (_, ranges) = crate::tui::screens::details::workflow_step_ranges(
area.width,
&self.state,
details,
has_languages,
is_series,
streams_count,
);
for (pane, start_x, end_x) in ranges {
if col >= start_x && col < end_x {
self.state.details_pane = pane;
return None;
}
}
return None;
}
let visible_selector_panes = crate::tui::screens::details::visible_selector_panes(
&available_panes,
self.state.details_pane,
area.width,
);
let selector_height = if visible_selector_panes.is_empty() {
0
} else {
let episode_count = self
.state
.available_episode_numbers
.get(self.state.season_list_state.selected().unwrap_or(0))
.map_or(0, Vec::len);
let language_count = dubs_count;
let max_visible_items = visible_selector_panes
.iter()
.map(|pane| match pane {
DetailsPane::Languages => language_count,
DetailsPane::Seasons => self.state.available_seasons.len(),
DetailsPane::Episodes => episode_count,
DetailsPane::Streams => 0,
})
.max()
.unwrap_or(0);
max_visible_items.min((bottom_area.height / 3).clamp(4, 10) as usize) as u16 + 2
};
let lower_chunks =
Layout::vertical([Constraint::Length(selector_height), Constraint::Min(3)])
.split(bottom_area);
let selector_area = lower_chunks[0];
let streams_area = lower_chunks[1];
if !visible_selector_panes.is_empty()
&& selector_area.contains(ratatui::layout::Position::new(col, row))
{
let selector_constraints = crate::tui::screens::details::selector_pane_constraints(
&visible_selector_panes,
selector_area.width,
);
let selector_chunks = Layout::horizontal(selector_constraints).split(selector_area);
for (pane, pane_rect) in visible_selector_panes
.into_iter()
.zip(selector_chunks.iter())
{
if pane_rect.contains(ratatui::layout::Position::new(col, row)) {
let clicked_row = row.saturating_sub(pane_rect.y + 1) as usize;
match pane {
DetailsPane::Languages => {
self.state.details_pane = DetailsPane::Languages;
if clicked_row < dubs_count {
self.action_sender
.send(Action::SelectLanguage(clicked_row))
.ok();
}
}
DetailsPane::Seasons => {
self.state.details_pane = DetailsPane::Seasons;
let offset = self.state.season_list_state.offset();
let abs_row = offset + clicked_row;
if abs_row < self.state.available_seasons.len() {
self.state.season_list_state.select(Some(abs_row));
self.state.selected_season = self
.state
.available_seasons
.get(abs_row)
.map(|s| s.number)
.unwrap_or(1);
self.state.episode_list_state.select(Some(0));
self.trigger_episode_fetch();
}
}
DetailsPane::Episodes => {
self.state.details_pane = DetailsPane::Episodes;
let offset = self.state.episode_list_state.offset();
let abs_row = offset + clicked_row;
let season_idx = self.state.season_list_state.selected().unwrap_or(0);
if let Some(ep_numbers) =
self.state.available_episode_numbers.get(season_idx)
{
if abs_row < ep_numbers.len() {
self.state.episode_list_state.select(Some(abs_row));
self.state.selected_episode = ep_numbers[abs_row];
self.trigger_episode_fetch();
}
}
}
DetailsPane::Streams => {}
}
return None;
}
}
}
if streams_area.contains(ratatui::layout::Position::new(col, row)) {
self.state.details_pane = DetailsPane::Streams;
let streams_count = self.state.selected_resources.len();
if streams_count > 0 {
let list_start_y = if streams_area.height >= 4 {
streams_area.y.saturating_add(2)
} else {
streams_area.y.saturating_add(1)
};
let list_end_y = streams_area.bottom().saturating_sub(1);
if row >= list_start_y && row < list_end_y {
let relative_row = (row - list_start_y) as usize;
let clicked_stream_idx = self
.state
.resource_list_state
.offset()
.saturating_add(relative_row);
if clicked_stream_idx < streams_count {
self.state
.resource_list_state
.select(Some(clicked_stream_idx));
if self.state.is_playing {
self.state.notify(
NotificationKind::Warning,
"Playback active",
"Player is already running.",
);
} else if !self.state.is_resolving_playback
&& self.state.last_playback_launch.elapsed().as_millis() >= 500
{
self.action_sender.send(Action::PlayStream).ok();
}
}
}
}
return None;
}
None
}
fn handle_details_footer_click(&mut self, col: u16, line_idx: u16, width: u16) {
let is_streams = self.state.details_pane == DetailsPane::Streams;
let is_seasons = self.state.details_pane == DetailsPane::Seasons;
let is_episodes = self.state.details_pane == DetailsPane::Episodes;
let compact = width < crate::tui::screens::details::DETAILS_FOOTER_SPLIT_THRESHOLD;
let is_favorited = self.state.is_selected_details_favorited();
let fav_label_len = if is_favorited { 10 } else { 8 };
enum FooterAction {
PlaySelect,
Download,
StreamsTab,
Favorite,
Info,
}
let (enter_len, d_label_len) = if is_streams {
(4, Some(if compact { 4 } else { 8 }))
} else if is_seasons {
(6, Some(if compact { 8 } else { 15 }))
} else if is_episodes {
(6, Some(if compact { 8 } else { 16 }))
} else {
(6, None)
};
let mut primary = vec![(FooterAction::PlaySelect, 7 + 1 + enter_len)];
if let Some(d_len) = d_label_len {
primary.push((FooterAction::Download, 3 + 1 + d_len));
}
let mut secondary = Vec::new();
if !is_streams {
secondary.push((FooterAction::StreamsTab, 5 + 1 + 7));
}
secondary.push((FooterAction::Favorite, 3 + 1 + fav_label_len));
secondary.push((FooterAction::Info, 3 + 1 + 4));
let active_buttons =
if width >= crate::tui::screens::details::DETAILS_FOOTER_SPLIT_THRESHOLD {
if line_idx > 0 {
return;
}
let mut combined = primary;
combined.extend(secondary);
combined
} else if line_idx == 0 {
primary
} else {
secondary
};
let sep = 3_u16;
let total_w: u16 = active_buttons.iter().map(|(_, w)| *w).sum::<u16>()
+ (active_buttons.len().saturating_sub(1) as u16) * sep;
let mut curr_x = width.saturating_sub(total_w) / 2;
for (action, w) in active_buttons {
let start = curr_x;
let end = start + w;
if col >= start && col < end + sep {
match action {
FooterAction::PlaySelect => match self.state.details_pane {
DetailsPane::Streams => {
self.action_sender.send(Action::PlayStream).ok();
}
DetailsPane::Seasons | DetailsPane::Episodes => {
self.trigger_episode_fetch();
}
DetailsPane::Languages => {
let idx = self.state.language_list_state.selected().unwrap_or(0);
self.action_sender.send(Action::SelectLanguage(idx)).ok();
}
},
FooterAction::Download => {
if is_seasons {
self.action_sender.send(Action::DownloadSeason).ok();
} else {
self.action_sender.send(Action::DownloadEpisode).ok();
}
}
FooterAction::Favorite => {
self.action_sender.send(Action::ToggleFavorite).ok();
}
FooterAction::Info => {
if let Some((title, content)) = self.state.active_overview() {
self.state.open_overview_modal(title, content);
}
}
FooterAction::StreamsTab => {
self.action_sender.send(Action::TabPane).ok();
}
}
return;
}
curr_x += w + sep;
}
}
}
fn click_in_picker(
popup: Rect,
col: u16,
row: u16,
state: &ratatui::widgets::ListState,
total_items: usize,
area: Rect,
) -> Option<Option<usize>> {
if !popup.contains(ratatui::layout::Position::new(col, row)) {
return None;
}
let visible_rows = total_items.clamp(1, crate::tui::overlay::max_picker_rows(area));
let offset = state.offset();
let item_y = popup.y.saturating_add(1);
if row >= item_y && (row - item_y) < visible_rows as u16 {
Some(Some(offset + (row - item_y) as usize))
} else {
Some(None)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::models::{
AudioTrackOption, MediaDetails, MediaType, ProviderKind, ProviderMediaId, Release,
};
use crate::tui::action::Action;
use crate::tui::state::DetailsPane;
use ratatui::layout::Rect;
#[test]
fn test_details_streams_panel_click_empty_space_does_not_open_stream() {
let mut app = App::new();
app.state.active_screen = crate::tui::state::Screen::Details;
app.state.details_pane = DetailsPane::Languages;
app.state.selected_details = Some(MediaDetails {
id: ProviderMediaId {
provider: ProviderKind::MovieBox,
value: "test_movie".to_string(),
},
title: "Test Movie".to_string(),
media_type: MediaType::Movie,
year: Some("2025".to_string()),
description: Some("Short description".to_string()),
tagline: None,
imdb_rating: Some("4.6".to_string()),
director: None,
stars: None,
prints: None,
audios: None,
poster_url: Some("https://example.com/poster.jpg".to_string()),
duration: Some("2h".to_string()),
genres: vec![],
seasons: vec![],
dubs: vec![
AudioTrackOption {
subject_id: "1".to_string(),
language: "Original".to_string(),
label: "Original".to_string(),
},
AudioTrackOption {
subject_id: "2".to_string(),
language: "Hindi".to_string(),
label: "Hindi".to_string(),
},
],
});
app.state.selected_resources = vec![Release {
provider: ProviderKind::MovieBox,
filename: "Movie.1080p.mkv".to_string(),
quality: Some("1080p".to_string()),
codec: Some("HEVC".to_string()),
language: None,
size_bytes: Some(1024 * 1024 * 1024),
season: None,
episode: None,
mirrors: vec![],
resource_id: None,
}];
app.state.resource_list_state.select(Some(0));
let area = Rect::new(0, 0, 120, 30);
let layout = crate::tui::screens::details::details_screen_layout(
area,
app.state.selected_details.as_ref(),
);
let bottom_area = layout.bottom_area;
let lower_chunks =
Layout::vertical([Constraint::Length(4), Constraint::Min(3)]).split(bottom_area);
let streams_area = lower_chunks[1];
let empty_space_row = streams_area.bottom().saturating_sub(3);
let action = app.handle_details_mouse(streams_area.x + 10, empty_space_row, area);
assert!(action.is_none());
assert_eq!(app.state.details_pane, DetailsPane::Streams);
assert_eq!(app.state.resource_list_state.selected(), Some(0));
let mut received_play = false;
while let Ok(act) = app.action_receiver.try_recv() {
if matches!(act, Action::PlayStream) {
received_play = true;
}
}
assert!(!received_play);
let stream_item_row = if streams_area.height >= 4 {
streams_area.y + 2
} else {
streams_area.y + 1
};
let action_stream = app.handle_details_mouse(streams_area.x + 10, stream_item_row, area);
assert!(action_stream.is_none());
assert_eq!(app.state.details_pane, DetailsPane::Streams);
let mut stream_played = false;
while let Ok(act) = app.action_receiver.try_recv() {
if matches!(act, Action::PlayStream) {
stream_played = true;
}
}
assert!(stream_played);
}
#[tokio::test]
async fn test_home_no_results_mouse_click_actions() {
let mut app = App::new();
app.state.active_screen = crate::tui::state::Screen::Home;
app.state.input_mode = crate::tui::state::InputMode::Normal;
app.state.is_tv_mode = false;
app.state.active_provider = ProviderKind::FourKHdHub;
app.state.search_query.set_content("deewaniyat");
app.state.search_results = vec![];
let area = Rect::new(0, 0, 100, 30);
let (_search_bar_area, results_chunk) =
crate::tui::screens::home::search_results_layout(area);
let next_label = app.state.next_provider().label();
let ctrl_p = crate::tui::text::CTRL_P_STR;
let (btn1, btn2) = crate::tui::screens::home::no_results_button_hitboxes(
results_chunk,
next_label,
ctrl_p,
app.state.is_tv_mode,
);
app.handle_home_mouse(btn2.x + 1, btn2.y, area);
assert!(app.state.search_query.is_empty());
app.state.search_query.set_content("deewaniyat");
app.handle_home_mouse(btn1.x + 1, btn1.y, area);
assert_ne!(app.state.active_provider, ProviderKind::FourKHdHub);
}
#[tokio::test]
async fn test_home_provider_pill_mouse_click_opens_popup() {
let original_config = crate::config::load();
let mut app = App::new();
app.state.active_screen = crate::tui::state::Screen::Home;
app.state.input_mode = crate::tui::state::InputMode::Normal;
app.state.is_tv_mode = false;
app.state.active_provider = ProviderKind::MovieBox;
app.state.search_query.clear();
let area = Rect::new(0, 0, 100, 30);
let card_width = crate::tui::screens::home::search_deck_width(area, &app.state, true);
let card_x = area.x + area.width.saturating_sub(card_width) / 2;
let (_tier, rows) = crate::tui::screens::home::landing_split(
area,
app.state.is_tv_mode,
app.state.basic_terminal,
app.state.landing_deck_visible(),
);
let search_card_area = Rect {
x: card_x,
y: rows.rects[rows.search].y,
width: card_width,
height: rows.rects[rows.search].height,
};
let pill_rect =
crate::tui::screens::home::search_bar_provider_pill_rect(search_card_area, &app.state);
app.handle_home_mouse(pill_rect.x + 1, pill_rect.y, area);
assert!(app.state.show_provider_popup);
assert_eq!(app.state.provider_list_state.selected(), Some(0));
let available = app.state.available_providers();
let (_container, inner) = crate::tui::screens::home::provider_popup_bounds(
area,
search_card_area,
available.len(),
);
let fourk_idx = available
.iter()
.position(|p| *p == ProviderKind::FourKHdHub)
.unwrap();
let target_y = inner.y + fourk_idx as u16;
app.handle_home_mouse(inner.x + 1, target_y, area);
assert!(!app.state.show_provider_popup);
assert_eq!(app.state.active_provider, ProviderKind::FourKHdHub);
app.handle_home_mouse(pill_rect.x + 1, pill_rect.y, area);
assert!(app.state.show_provider_popup);
let last_idx = available.len() - 1;
let last_provider = available[last_idx];
let last_target_y = inner.y + last_idx as u16;
app.handle_home_mouse(inner.x + 1, last_target_y, area);
assert!(!app.state.show_provider_popup);
assert_eq!(app.state.active_provider, last_provider);
let pill_rect =
crate::tui::screens::home::search_bar_provider_pill_rect(search_card_area, &app.state);
app.handle_home_mouse(pill_rect.x + 1, pill_rect.y, area);
assert!(app.state.show_provider_popup);
app.handle_home_mouse(area.x, area.y, area);
assert!(!app.state.show_provider_popup);
assert_eq!(app.state.active_provider, last_provider);
crate::config::save(&original_config);
}
#[tokio::test]
async fn test_download_cancel_mouse_hitbox() {
let mut app = App::new();
let area = Rect::new(0, 0, 80, 24);
app.state.download_progress = Some(50.0);
app.state
.cancel_download
.store(false, std::sync::atomic::Ordering::SeqCst);
let handled = app.handle_overlay_mouse(20, 22, area);
assert!(handled);
assert!(app.action_receiver.try_recv().is_err());
let handled_cancel = app.handle_overlay_mouse(72, 21, area);
assert!(handled_cancel);
assert!(matches!(
app.action_receiver.try_recv().ok(),
Some(Action::CancelDownload)
));
}
#[tokio::test]
async fn test_subtitle_popup_outside_click_emits_cancellation() {
let mut app = App::new();
let area = Rect::new(0, 0, 80, 24);
app.state.subtitle_popup = true;
app.state.subtitle_list = vec![("English".to_string(), "https://sub.url".to_string())];
let handled = app.handle_overlay_mouse(0, 0, area);
assert!(handled);
assert!(!app.state.subtitle_popup);
let notif = app.state.notifications.back().expect("notification posted");
assert_eq!(notif.title, "Playback Cancelled");
}
#[tokio::test]
async fn test_details_header_mouse_click_opens_overview_modal_and_outside_click_dismisses() {
let mut app = App::new();
let area = Rect::new(0, 0, 100, 30);
app.state.active_screen = Screen::Details;
app.state.selected_details = Some(crate::providers::models::MediaDetails {
id: crate::providers::models::ProviderMediaId {
provider: crate::providers::models::ProviderKind::MovieBox,
value: "sample_series".to_string(),
},
title: "Stranger Things".to_string(),
media_type: crate::providers::models::MediaType::Series,
year: Some("2016".to_string()),
description: Some("Full synopsis about the Upside Down.".to_string()),
tagline: None,
imdb_rating: None,
director: None,
stars: None,
prints: None,
audios: None,
poster_url: None,
duration: None,
genres: vec![],
seasons: vec![],
dubs: vec![],
});
assert!(!app.state.show_overview_modal);
let layout = crate::tui::screens::details::details_screen_layout(
area,
app.state.selected_details.as_ref(),
);
let non_synopsis_x = layout.header_area.x + 2;
let non_synopsis_y = layout.header_area.y;
app.handle_details_mouse(non_synopsis_x, non_synopsis_y, area);
assert!(!app.state.show_overview_modal);
let synopsis_click_x = layout.synopsis_area.x + 2;
let synopsis_click_y = layout.synopsis_area.y;
app.handle_details_mouse(synopsis_click_x, synopsis_click_y, area);
assert!(app.state.show_overview_modal);
assert_eq!(app.state.overview_modal_title, "Stranger Things · Synopsis");
assert_eq!(
app.state.overview_modal_content,
"Full synopsis about the Upside Down."
);
let outside_handled = app.handle_overlay_mouse(0, 0, area);
assert!(outside_handled);
assert!(!app.state.show_overview_modal);
}
}