Dark-Alex-17/managarr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added tabs and navigation for movie info

Browse Source
This commit is contained in:
Dark-Alex-17
2023-08-08 10:50:04 -06:00
parent c16f234088
commit daf08c10cc
7 changed files with 520 additions and 263 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/ui/mod.rs
+84 -11
View File
@@ -1,17 +1,22 @@
use tui::backend::Backend;
use tui::layout::{Constraint, Rect};
use tui::text::Text;
use tui::widgets::{Block, Borders, Clear, Paragraph};
use tui::text::{Span, Spans, Text};
use tui::widgets::Block;
use tui::widgets::Clear;
use tui::widgets::Paragraph;
use tui::widgets::Row;
use tui::widgets::Table;
use tui::widgets::Tabs;
use tui::Frame;
use crate::app::radarr::ActiveRadarrBlock;
use crate::app::models::{StatefulTable, TabState};
use crate::app::{App, Route};
use crate::logos::{
BAZARR_LOGO, LIDARR_LOGO, PROWLARR_LOGO, RADARR_LOGO, READARR_LOGO, SONARR_LOGO,
};
use crate::ui::utils::{
centered_rect, horizontal_chunks, horizontal_chunks_with_margin, style_system_function,
style_warning, vertical_chunks, vertical_chunks_with_margin,
centered_rect, layout_block_top_border, style_default_bold, style_highlight, style_secondary,
style_system_function, title_block, vertical_chunks_with_margin,
};
mod radarr_ui;
@@ -27,7 +32,7 @@ pub fn ui<B: Backend>(f: &mut Frame<B>, app: &mut App) {
);
draw_context_row(f, app, main_chunks[0]);
match app.get_current_route().clone() {
match app.get_current_route() {
Route::Radarr(_) => radarr_ui::draw_radarr_ui(f, app, main_chunks[1]),
}
}
@@ -37,7 +42,7 @@ pub fn draw_popup_over<B: Backend>(
app: &mut App,
area: Rect,
background_fn: fn(&mut Frame<'_, B>, &mut App, Rect),
popup_fn: fn(&mut Frame<'_, B>, &App, Rect),
popup_fn: fn(&mut Frame<'_, B>, &mut App, Rect),
percent_x: u16,
percent_y: u16,
) {
@@ -53,7 +58,7 @@ pub fn draw_small_popup_over<B: Backend>(
app: &mut App,
area: Rect,
background_fn: fn(&mut Frame<'_, B>, &mut App, Rect),
popup_fn: fn(&mut Frame<'_, B>, &App, Rect),
popup_fn: fn(&mut Frame<'_, B>, &mut App, Rect),
) {
draw_popup_over(f, app, area, background_fn, popup_fn, 40, 40);
}
@@ -63,7 +68,7 @@ pub fn draw_medium_popup_over<B: Backend>(
app: &mut App,
area: Rect,
background_fn: fn(&mut Frame<'_, B>, &mut App, Rect),
popup_fn: fn(&mut Frame<'_, B>, &App, Rect),
popup_fn: fn(&mut Frame<'_, B>, &mut App, Rect),
) {
draw_popup_over(f, app, area, background_fn, popup_fn, 60, 60);
}
@@ -73,17 +78,85 @@ pub fn draw_large_popup_over<B: Backend>(
app: &mut App,
area: Rect,
background_fn: fn(&mut Frame<'_, B>, &mut App, Rect),
popup_fn: fn(&mut Frame<'_, B>, &App, Rect),
popup_fn: fn(&mut Frame<'_, B>, &mut App, Rect),
) {
draw_popup_over(f, app, area, background_fn, popup_fn, 75, 75);
}
fn draw_context_row<B: Backend>(f: &mut Frame<'_, B>, app: &App, area: Rect) {
match app.get_current_route().clone() {
match app.get_current_route() {
Route::Radarr(_) => radarr_ui::draw_radarr_context_row(f, app, area),
}
}
fn draw_tabs<'a, B: Backend>(
f: &mut Frame<'_, B>,
area: Rect,
title: &str,
tab_state: &TabState,
) -> (Rect, Block<'a>) {
let chunks =
vertical_chunks_with_margin(vec![Constraint::Length(2), Constraint::Min(0)], area, 1);
let block = title_block(title);
let titles = tab_state
.tabs
.iter()
.map(|tab_route| Spans::from(Span::styled(&tab_route.title, style_default_bold())))
.collect();
let tabs = Tabs::new(titles)
.block(block)
.highlight_style(style_secondary())
.select(tab_state.index);
f.render_widget(tabs, area);
(chunks[1], layout_block_top_border())
}
pub struct TableProps<'a, T> {
pub content: &'a mut StatefulTable<T>,
pub table_headers: Vec<&'a str>,
pub constraints: Vec<Constraint>,
}
fn draw_table<'a, B, T, F>(
f: &mut Frame<'_, B>,
content_area: Rect,
block: Block,
table_props: TableProps<'a, T>,
row_mapper: F,
is_loading: bool,
) where
B: Backend,
F: Fn(&T) -> Row<'a>,
{
let TableProps {
content,
table_headers,
constraints,
} = table_props;
if !content.items.is_empty() {
let rows = content.items.iter().map(row_mapper);
let headers = Row::new(table_headers)
.style(style_default_bold())
.bottom_margin(0);
let table = Table::new(rows)
.header(headers)
.block(block)
.highlight_style(style_highlight())
.highlight_symbol(HIGHLIGHT_SYMBOL)
.widths(&constraints);
f.render_stateful_widget(table, content_area, &mut content.state);
} else {
loading(f, block, content_area, is_loading);
}
}
pub fn loading<B: Backend>(f: &mut Frame<'_, B>, block: Block<'_>, area: Rect, is_loading: bool) {
if is_loading {
let text = "\n\n Loading ...\n\n".to_owned();
src/ui/radarr_ui.rs
+186 -134
View File
@@ -2,50 +2,35 @@ use std::iter;
use std::ops::Sub;
use chrono::{Duration, Utc};
use log::debug;
use tui::backend::Backend;
use tui::layout::{Alignment, Constraint, Rect};
use tui::style::Style;
use tui::text::{Span, Spans, Text};
use tui::widgets::{Block, Borders, Cell, Paragraph, Row, Table, Tabs, Wrap};
use tui::text::Text;
use tui::widgets::{Block, Cell, Paragraph, Row, Wrap};
use tui::Frame;
use crate::app::radarr::{ActiveRadarrBlock, RadarrData};
use crate::app::{App, Route};
use crate::logos::RADARR_LOGO;
use crate::network::radarr_network::{DownloadRecord, Movie};
use crate::network::radarr_network::{DiskSpace, DownloadRecord, Movie, MovieHistoryItem};
use crate::ui::utils::{
horizontal_chunks_with_margin, line_gague, style_default, style_failure, style_highlight,
style_secondary, style_success, style_warning, title_block, vertical_chunks_with_margin,
horizontal_chunks_with_margin, layout_block_top_border, line_gague_with_label,
line_gague_with_title, style_bold, style_failure, style_success, style_warning, title_block,
vertical_chunks_with_margin,
};
use crate::ui::{draw_small_popup_over, loading, HIGHLIGHT_SYMBOL};
use crate::ui::{draw_large_popup_over, draw_table, draw_tabs, loading, TableProps};
use crate::utils::{convert_runtime, convert_to_gb};
pub(super) fn draw_radarr_ui<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, area: Rect) {
let chunks =
vertical_chunks_with_margin(vec![Constraint::Length(2), Constraint::Min(0)], area, 1);
let block = title_block(" Movies");
let titles = app
.data
.radarr_data
.main_tabs
.tabs
.iter()
.map(|tab_route| Spans::from(Span::styled(&tab_route.title, style_default())))
.collect();
let tabs = Tabs::new(titles)
.block(block)
.highlight_style(style_secondary())
.select(app.data.radarr_data.main_tabs.index);
f.render_widget(tabs, area);
let (content_rect, _) = draw_tabs(f, area, " Movies ", &app.data.radarr_data.main_tabs);
if let Route::Radarr(active_radarr_block) = app.get_current_route() {
match active_radarr_block {
ActiveRadarrBlock::Movies => draw_radarr_library(f, app, chunks[1]),
ActiveRadarrBlock::Downloads => draw_downloads(f, app, chunks[1]),
ActiveRadarrBlock::MovieDetails => {
draw_small_popup_over(f, app, chunks[1], draw_radarr_library, draw_movie_details)
ActiveRadarrBlock::Movies => draw_library(f, app, content_rect),
ActiveRadarrBlock::Downloads => draw_downloads(f, app, content_rect),
ActiveRadarrBlock::MovieDetails | ActiveRadarrBlock::MovieHistory => {
draw_large_popup_over(f, app, content_rect, draw_library, draw_movie_info)
}
_ => (),
}
@@ -54,70 +39,67 @@ pub(super) fn draw_radarr_ui<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, ar
pub(super) fn draw_radarr_context_row<B: Backend>(f: &mut Frame<'_, B>, app: &App, area: Rect) {
let chunks = horizontal_chunks_with_margin(
vec![
Constraint::Ratio(1, 3),
Constraint::Ratio(1, 3),
Constraint::Ratio(1, 3),
],
vec![Constraint::Ratio(1, 2), Constraint::Ratio(1, 2)],
area,
1,
);
draw_stats_context(f, app, chunks[0]);
f.render_widget(Block::default().borders(Borders::ALL), chunks[1]);
draw_downloads_context(f, app, chunks[2]);
draw_downloads_context(f, app, chunks[1]);
}
fn draw_radarr_library<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, area: Rect) {
let block = Block::default().borders(Borders::TOP);
let movies_vec = &app.data.radarr_data.movies.items;
fn draw_library<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, area: Rect) {
let quality_profile_map = &app.data.radarr_data.quality_profile_map;
let downloads_vec = &app.data.radarr_data.downloads.items;
if !movies_vec.is_empty() {
let rows = movies_vec.iter().map(|movie| {
draw_table(
f,
area,
layout_block_top_border(),
TableProps {
content: &mut app.data.radarr_data.movies,
table_headers: vec![
"Title",
"Year",
"Runtime",
"Rating",
"Language",
"Size",
"Quality Profile",
],
constraints: vec![
Constraint::Percentage(25),
Constraint::Percentage(12),
Constraint::Percentage(12),
Constraint::Percentage(12),
Constraint::Percentage(12),
Constraint::Percentage(12),
Constraint::Percentage(12),
],
},
|movie| {
let (hours, minutes) = convert_runtime(movie.runtime.as_u64().unwrap());
let file_size: f64 = convert_to_gb(movie.size_on_disk.as_u64().unwrap());
let certification = movie.certification.clone().unwrap_or_else(|| "".to_owned());
Row::new(vec![
Cell::from(movie.title.to_owned()),
Cell::from(movie.year.to_string()),
Cell::from(format!("{}h {}m", hours, minutes)),
Cell::from(certification),
Cell::from(movie.original_language.name.to_owned()),
Cell::from(format!("{:.2} GB", file_size)),
Cell::from(
app
.data
.radarr_data
.quality_profile_map
quality_profile_map
.get(&movie.quality_profile_id.as_u64().unwrap())
.unwrap()
.to_owned(),
),
])
.style(determine_row_style(app, movie))
});
let header_row = Row::new(vec!["Title", "Year", "Runtime", "Size", "Quality Profile"])
.style(style_default())
.bottom_margin(0);
let constraints = vec![
Constraint::Percentage(20),
Constraint::Percentage(20),
Constraint::Percentage(20),
Constraint::Percentage(20),
Constraint::Percentage(20),
];
let table = Table::new(rows)
.header(header_row)
.block(block)
.highlight_style(style_highlight())
.highlight_symbol(HIGHLIGHT_SYMBOL)
.widths(&constraints);
f.render_stateful_widget(table, area, &mut app.data.radarr_data.movies.state);
} else {
loading(f, block, area, app.is_loading);
}
.style(determine_row_style(downloads_vec, movie))
},
app.is_loading,
);
}
fn draw_downloads_context<B: Backend>(f: &mut Frame<'_, B>, app: &App, area: Rect) {
@@ -141,7 +123,7 @@ fn draw_downloads_context<B: Backend>(f: &mut Frame<'_, B>, app: &App, area: Rec
..
} = &downloads_vec[i];
let percent = 1f64 - (sizeleft.as_f64().unwrap() / size.as_f64().unwrap());
let download_gague = line_gague(title, percent);
let download_gague = line_gague_with_title(title, percent);
f.render_widget(download_gague, chunks[i]);
}
@@ -151,11 +133,30 @@ fn draw_downloads_context<B: Backend>(f: &mut Frame<'_, B>, app: &App, area: Rec
}
fn draw_downloads<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, area: Rect) {
let block = Block::default().borders(Borders::TOP);
let downloads_vec = &app.data.radarr_data.downloads.items;
if !downloads_vec.is_empty() {
let rows = downloads_vec.iter().map(|download_record| {
draw_table(
f,
area,
layout_block_top_border(),
TableProps {
content: &mut app.data.radarr_data.downloads,
table_headers: vec![
"Title",
"Percent Complete",
"Size",
"Output Path",
"Indexer",
"Download Client",
],
constraints: vec![
Constraint::Percentage(30),
Constraint::Percentage(11),
Constraint::Percentage(11),
Constraint::Percentage(18),
Constraint::Percentage(17),
Constraint::Percentage(13),
],
},
|download_record| {
let DownloadRecord {
title,
size,
@@ -177,43 +178,32 @@ fn draw_downloads<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, area: Rect) {
Cell::from(download_client.to_owned()),
])
.style(style_success())
});
},
app.is_loading,
);
}
let header_row = Row::new(vec![
"Title",
"Percent Complete",
"Size",
"Output Path",
"Indexer",
"Download Client",
])
.style(style_default())
.bottom_margin(0);
fn draw_movie_info<B: Backend>(f: &mut Frame<'_, B>, app: &mut App, area: Rect) {
let (content_area, block) =
draw_tabs(f, area, "Movie Info", &app.data.radarr_data.movie_info_tabs);
let constraints = vec![
Constraint::Percentage(30),
Constraint::Percentage(11),
Constraint::Percentage(11),
Constraint::Percentage(18),
Constraint::Percentage(17),
Constraint::Percentage(13),
];
let table = Table::new(rows)
.header(header_row)
.block(block)
.highlight_style(style_highlight())
.highlight_symbol(HIGHLIGHT_SYMBOL)
.widths(&constraints);
f.render_stateful_widget(table, area, &mut app.data.radarr_data.downloads.state);
} else {
loading(f, block, area, app.is_loading);
if let Route::Radarr(active_radarr_block) =
app.data.radarr_data.movie_info_tabs.get_active_route()
{
match active_radarr_block {
ActiveRadarrBlock::MovieDetails => draw_movie_details(f, app, content_area, block),
ActiveRadarrBlock::MovieHistory => draw_movie_history(f, app, content_area, block),
_ => (),
}
}
}
fn draw_movie_details<B: Backend>(f: &mut Frame<'_, B>, app: &App, area: Rect) {
let block = title_block("Movie Details");
fn draw_movie_details<B: Backend>(
f: &mut Frame<'_, B>,
app: &App,
content_area: Rect,
block: Block,
) {
let movie_details = app.data.radarr_data.movie_details.get_text();
if !movie_details.is_empty() {
@@ -235,48 +225,94 @@ fn draw_movie_details<B: Backend>(f: &mut Frame<'_, B>, app: &App, area: Rect) {
.wrap(Wrap { trim: false })
.scroll((app.data.radarr_data.movie_details.offset, 0));
f.render_widget(paragraph, area);
f.render_widget(paragraph, content_area);
} else {
loading(f, block, area, app.is_loading);
loading(f, block, content_area, app.is_loading);
}
}
fn draw_movie_history<B: Backend>(
f: &mut Frame<'_, B>,
app: &mut App,
content_area: Rect,
block: Block,
) {
draw_table(
f,
content_area,
block,
TableProps {
content: &mut app.data.radarr_data.movie_history,
table_headers: vec!["Source Title", "Event Type", "Languages", "Quality", "Date"],
constraints: vec![
Constraint::Percentage(34),
Constraint::Percentage(17),
Constraint::Percentage(14),
Constraint::Percentage(14),
Constraint::Percentage(21),
],
},
|movie_history_item| {
let MovieHistoryItem {
source_title,
quality,
languages,
date,
event_type,
} = movie_history_item;
Row::new(vec![
Cell::from(source_title.to_owned()),
Cell::from(event_type.to_owned()),
Cell::from(
languages
.iter()
.map(|language| language.name.to_owned())
.collect::<Vec<String>>()
.join(","),
),
Cell::from(quality.quality.name.to_owned()),
Cell::from(date.to_string()),
])
.style(style_success())
},
app.is_loading,
);
}
fn draw_stats_context<B: Backend>(f: &mut Frame<'_, B>, app: &App, area: Rect) {
let block = title_block("Stats");
if !app.data.radarr_data.version.is_empty() {
f.render_widget(block, area);
let RadarrData {
free_space,
total_space,
disk_space_vec,
start_time,
..
} = app.data.radarr_data;
let ratio = if total_space == 0 {
0f64
} else {
1f64 - (free_space as f64 / total_space as f64)
};
} = &app.data.radarr_data;
f.render_widget(block, area);
let mut constraints = vec![
Constraint::Percentage(60),
Constraint::Length(1),
Constraint::Length(1),
Constraint::Length(1),
];
let chunks = vertical_chunks_with_margin(
vec![
Constraint::Percentage(60),
Constraint::Length(1),
Constraint::Length(1),
Constraint::Min(2),
],
area,
1,
constraints.append(
&mut iter::repeat(Constraint::Min(2))
.take(disk_space_vec.len())
.collect(),
);
let chunks = vertical_chunks_with_margin(constraints, area, 1);
let version_paragraph = Paragraph::new(Text::from(format!(
"Radarr Version: {}",
app.data.radarr_data.version
)))
.block(Block::default());
let uptime = Utc::now().sub(start_time);
let uptime = Utc::now().sub(start_time.to_owned());
let days = uptime.num_days();
let day_difference = uptime.sub(Duration::days(days));
let hours = day_difference.num_hours();
@@ -296,23 +332,39 @@ fn draw_stats_context<B: Backend>(f: &mut Frame<'_, B>, app: &App, area: Rect) {
)))
.block(Block::default());
let space_gauge = line_gague("Storage:", ratio);
let logo = Paragraph::new(Text::from(RADARR_LOGO))
.block(Block::default())
.alignment(Alignment::Center);
let storage =
Paragraph::new(Text::from("Storage:")).block(Block::default().style(style_bold()));
f.render_widget(logo, chunks[0]);
f.render_widget(version_paragraph, chunks[1]);
f.render_widget(uptime_paragraph, chunks[2]);
f.render_widget(space_gauge, chunks[3]);
f.render_widget(storage, chunks[3]);
for i in 0..disk_space_vec.len() {
let DiskSpace {
free_space,
total_space,
} = &disk_space_vec[i];
let title = format!("Disk {}", i + 1);
let ratio = if total_space.as_u64().unwrap() == 0 {
0f64
} else {
1f64 - (free_space.as_u64().unwrap() as f64 / total_space.as_u64().unwrap() as f64)
};
let space_gauge = line_gague_with_label(title.as_str(), ratio);
f.render_widget(space_gauge, chunks[i + 4]);
}
} else {
loading(f, block, area, app.is_loading);
}
}
fn determine_row_style(app: &App, movie: &Movie) -> Style {
let downloads_vec = &app.data.radarr_data.downloads.items;
fn determine_row_style(downloads_vec: &[DownloadRecord], movie: &Movie) -> Style {
if !movie.has_file {
if let Some(download) = downloads_vec
.iter()
src/ui/utils.rs
+27 -6
View File
@@ -50,12 +50,20 @@ pub fn vertical_chunks_with_margin(
.split(size)
}
pub fn layout_block(title_span: Span<'_>) -> Block<'_> {
Block::default().borders(Borders::ALL).title(title_span)
pub fn layout_block<'a>() -> Block<'a> {
Block::default().borders(Borders::ALL)
}
pub fn layout_block_top_border(title_span: Span<'_>) -> Block<'_> {
Block::default().borders(Borders::TOP).title(title_span)
pub fn layout_block_with_title(title_span: Span<'_>) -> Block<'_> {
layout_block().title(title_span)
}
pub fn layout_block_top_border_with_title(title_span: Span<'_>) -> Block<'_> {
layout_block_top_border().title(title_span)
}
pub fn layout_block_top_border<'a>() -> Block<'a> {
Block::default().borders(Borders::TOP)
}
pub fn style_bold() -> Style {
@@ -70,6 +78,10 @@ pub fn style_default() -> Style {
Style::default().fg(Color::White)
}
pub fn style_default_bold() -> Style {
style_default().add_modifier(Modifier::BOLD)
}
pub fn style_primary() -> Style {
Style::default().fg(Color::Cyan)
}
@@ -99,7 +111,7 @@ pub fn title_style(title: &str) -> Span<'_> {
}
pub fn title_block(title: &str) -> Block<'_> {
layout_block(title_style(title))
layout_block_with_title(title_style(title))
}
pub fn centered_rect(percent_x: u16, percent_y: u16, r: Rect) -> Rect {
@@ -128,7 +140,7 @@ pub fn centered_rect(percent_x: u16, percent_y: u16, r: Rect) -> Rect {
.split(popup_layout[1])[1]
}
pub fn line_gague(title: &str, ratio: f64) -> LineGauge {
pub fn line_gague_with_title(title: &str, ratio: f64) -> LineGauge {
LineGauge::default()
.block(Block::default().title(title))
.gauge_style(Style::default().fg(Color::Cyan))
@@ -136,3 +148,12 @@ pub fn line_gague(title: &str, ratio: f64) -> LineGauge {
.ratio(ratio)
.label(Spans::from(format!("{:.0}%", ratio * 100.0)))
}
pub fn line_gague_with_label(title: &str, ratio: f64) -> LineGauge {
LineGauge::default()
.block(Block::default())
.gauge_style(Style::default().fg(Color::Cyan))
.line_set(symbols::line::THICK)
.ratio(ratio)
.label(Spans::from(format!("{}: {:.0}%", title, ratio * 100.0)))
}