mrfluffy/kami
1
0
Fork 0
mirror of https://github.com/mrfluffy-dev/kami.git synced 2026-01-17 04:50:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor: refactor code layout by moving ui to another crates

Browse Source
This commit is contained in:
newbee1905
2023-02-02 22:26:18 +07:00
parent 2dea2c86ec
commit 2b4c1079ac
10 changed files with 789 additions and 779 deletions
Download Patch File Download Diff File Expand all files Collapse all files

431
src/anime/anime.rs
View File

@@ -1,124 +1,12 @@
use crate::{
get_an_history, get_an_progress, get_anime_id, get_user_anime_progress, update_anime_progress,
write_an_progress,
};
use crate::{get_anime_link, get_animes, get_image};
use crate::{open_cast, open_video};
use crossterm::{
event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
event::{DisableMouseCapture, EnableMouseCapture},
execute,
terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
};
use std::{error::Error, io};
use tui::{
backend::{Backend, CrosstermBackend},
layout::{Constraint, Direction, Layout},
style::{Color, Modifier, Style},
text::{Span, Spans, Text},
widgets::{Block, BorderType, Borders, List, ListItem, ListState, Paragraph},
Frame, Terminal,
};
use unicode_width::UnicodeWidthStr;
use viuer::{print_from_file, terminal_size, Config};
use tui::{backend::CrosstermBackend, Terminal};
use super::scraper::get_anime_info;
enum InputMode {
Normal,
Editing,
}
struct StatefulList<T> {
state: ListState,
items: Vec<T>,
}
impl<T> StatefulList<T> {
fn with_items(items: Vec<T>) -> StatefulList<T> {
StatefulList {
state: ListState::default(),
items,
}
}
fn next(&mut self) {
let i = match self.state.selected() {
Some(i) => {
if i >= self.items.len() - 1 {
0
} else {
i + 1
}
}
None => 0,
};
self.state.select(Some(i));
}
fn previous(&mut self) {
let i = match self.state.selected() {
Some(i) => {
if i == 0 {
self.items.len() - 1
} else {
i - 1
}
}
None => 0,
};
self.state.select(Some(i));
}
fn unselect(&mut self) {
self.state.select(None);
}
fn push(&mut self, item: T) {
self.items.push(item);
}
fn iter(&self) -> impl Iterator<Item = &T> {
self.items.iter()
}
}
struct App {
/// Current value of the input box
input: String,
animes: (Vec<String>, Vec<String>, Vec<String>),
image: String,
/// Current input mode
input_mode: InputMode,
/// History of recorded messages
messages: StatefulList<String>,
title: String,
link: String,
ep: u64,
progress: i32,
anime_id: i32,
token: String,
provider: String,
cast: (bool, String),
}
impl<'a> App {
fn default() -> App {
App {
input: String::new(),
animes: get_an_history(),
image: String::new(),
input_mode: InputMode::Normal,
messages: StatefulList::with_items(Vec::new()),
title: String::new(),
link: String::new(),
ep: 0,
progress: 0,
anime_id: 0,
token: String::new(),
provider: String::new(),
cast: (false, "0".to_string()),
}
}
}
use crate::ui::app::{anime::App, app::KamiApp};
pub fn anime_ui(
token: String,
@@ -133,11 +21,11 @@ pub fn anime_ui(
let mut terminal = Terminal::new(backend)?;
// create app and run it
let mut app = App::default();
let mut app = App::new();
app.token = token;
app.provider = provider;
app.cast = cast;
let res = run_app(&mut terminal, app);
let res = app.run(&mut terminal);
// restore terminal
disable_raw_mode()?;
@@ -154,312 +42,3 @@ pub fn anime_ui(
Ok(())
}
fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: App) -> io::Result<()> {
let mut ep_select = false;
fn change_image(app: &App) {
//save as f32
let (width, height) = terminal_size().to_owned();
let width = width as f32;
let height = height as f32;
let sixel_support = viuer::is_sixel_supported();
let config = match sixel_support {
true => Config {
x: ((width / 2.0) + 1.0).round() as u16,
y: 2,
width: Some((width / 1.3).round() as u32),
height: Some((height * 1.5) as u32),
restore_cursor: true,
..Default::default()
},
false => Config {
x: ((width / 2.0) + 1.0).round() as u16,
y: 2,
width: Some(((width / 2.0) - 4.0).round() as u32),
height: Some((height / 1.3).round() as u32),
restore_cursor: true,
..Default::default()
},
};
let config_path = dirs::config_dir().unwrap().join("kami");
let image_path = config_path.join("tmp.jpg");
get_image(&app.image, &image_path.to_str().unwrap());
print_from_file(image_path, &config).expect("Image printing failed.");
}
app.messages.items.clear();
for anime in &app.animes.1 {
app.messages.push(anime.to_string());
}
app.input_mode = InputMode::Normal;
loop {
terminal.draw(|f| ui(f, &mut app))?;
if let Event::Key(key) = event::read()? {
match app.input_mode {
InputMode::Normal => match key.code {
KeyCode::Char('i') => {
app.input_mode = InputMode::Editing;
}
KeyCode::Char('q') => {
return Ok(());
}
KeyCode::Left => app.messages.unselect(),
KeyCode::Char('h') => app.messages.unselect(),
KeyCode::Down => match ep_select {
true => {
app.messages.next();
}
false => {
app.messages.next();
let selected = app.messages.state.selected();
app.image = app.animes.2[selected.unwrap()].clone();
change_image(&app);
}
},
KeyCode::Char('j') => match ep_select {
true => {
app.messages.next();
}
false => {
app.messages.next();
let selected = app.messages.state.selected();
app.image = app.animes.2[selected.unwrap()].clone();
change_image(&app);
}
},
KeyCode::Up => match ep_select {
true => {
app.messages.previous();
}
false => {
app.messages.previous();
let selected = app.messages.state.selected();
app.image = app.animes.2[selected.unwrap()].clone();
change_image(&app);
}
},
KeyCode::Char('k') => match ep_select {
true => {
app.messages.previous();
}
false => {
app.messages.previous();
let selected = app.messages.state.selected();
app.image = app.animes.2[selected.unwrap()].clone();
change_image(&app);
}
},
//if KeyCode::Enter => {
KeyCode::Enter => {
if ep_select == false {
app.progress = 0;
let selected = app.messages.state.selected();
app.title = app.messages.items[selected.unwrap()].clone();
app.link = app.animes.0[selected.unwrap()].clone();
let anime_info = get_anime_info(&app.animes.0[selected.unwrap()]);
app.anime_id = get_anime_id(anime_info.0);
app.messages.items.clear();
if app.token == "local" || app.anime_id == 0 {
app.progress = get_an_progress(&app.title) as i32;
app.messages.state.select(Some(app.progress as usize));
} else {
app.progress =
get_user_anime_progress(app.anime_id, app.token.as_str());
app.messages.state.select(Some(app.progress as usize));
}
if anime_info.1 == 1 {
let link = get_anime_link(&app.link, 1);
if !app.cast.0 {
open_video((link, format!("{} Episode 1", &app.title)));
} else {
open_cast(
(link, format!("{} Episode 1", &app.title)),
&app.cast.1,
)
}
let selected = app.messages.state.selected();
let image_url = app.animes.2[selected.unwrap()].clone();
if app.token == "local" || app.anime_id == 0 {
write_an_progress((&app.title, &app.link, &image_url), &1);
} else {
update_anime_progress(app.anime_id, 1, app.token.as_str());
write_an_progress((&app.title, &app.link, &image_url), &1);
}
} else {
for ep in 1..anime_info.1 + 1 {
app.messages.push(format!("Episode {}", ep));
}
ep_select = true;
}
} else {
let selected = app.messages.state.selected();
app.ep = app
.messages
.iter()
.nth(selected.unwrap())
.unwrap()
.replace("Episode ", "")
.parse::<u64>()
.unwrap();
let link = get_anime_link(&app.link, app.ep);
if !app.cast.0 {
open_video((link, format!("{} Episode {}", &app.title, app.ep)));
} else {
open_cast(
(link, format!("{} Episode {}", &app.title, app.ep)),
&app.cast.1,
)
}
let image_url = &app.image;
if app.ep > app.progress as u64 {
if app.token == "local" || app.anime_id == 0 {
write_an_progress((&app.title, &app.link, &image_url), &app.ep);
} else {
update_anime_progress(
app.anime_id,
app.ep as usize,
app.token.as_str(),
);
write_an_progress((&app.title, &app.link, &image_url), &app.ep);
}
app.progress = app.ep as i32;
}
}
}
_ => {}
},
InputMode::Editing => match key.code {
KeyCode::Enter => {
//push app.input into app.messages with '
app.animes = get_animes(app.input.drain(..).collect());
app.messages.items.clear();
for anime in &app.animes.1 {
app.messages.push(anime.to_string());
}
ep_select = false;
app.input_mode = InputMode::Normal;
}
KeyCode::Char(c) => {
app.input.push(c);
}
KeyCode::Backspace => {
app.input.pop();
}
KeyCode::Esc => {
app.input_mode = InputMode::Normal;
}
_ => {}
},
}
}
}
}
fn ui<B: Backend>(f: &mut Frame<B>, app: &mut App) {
let chunks = Layout::default()
.direction(Direction::Vertical)
.margin(1)
.constraints(
[
Constraint::Min(1),
Constraint::Length(1),
Constraint::Length(3),
]
.as_ref(),
)
.split(f.size());
let block = Block::default()
.borders(Borders::ALL)
.title("kami")
.border_type(BorderType::Rounded);
f.render_widget(block, f.size());
let top_chunks = Layout::default()
.direction(Direction::Horizontal)
.constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
.split(chunks[0]);
let (msg, style) = match app.input_mode {
InputMode::Normal => (
vec![
Span::raw("Press "),
Span::styled("q", Style::default().add_modifier(Modifier::BOLD)),
Span::raw(" to exit, "),
Span::styled("i", Style::default().add_modifier(Modifier::BOLD)),
Span::raw(" to search."),
],
Style::default().add_modifier(Modifier::RAPID_BLINK),
),
InputMode::Editing => (
vec![
Span::raw("Press "),
Span::styled("Esc", Style::default().add_modifier(Modifier::BOLD)),
Span::raw(" to stop editing, "),
Span::styled("Enter", Style::default().add_modifier(Modifier::BOLD)),
Span::raw(" to select."),
],
Style::default(),
),
};
let messages: Vec<ListItem> = app
.messages
.iter()
.enumerate()
.map(|(i, m)| {
let content = vec![Spans::from(Span::raw(format!("{}: {}", i, m)))];
ListItem::new(content)
})
.collect();
let messages = List::new(messages)
.block(
Block::default()
.borders(Borders::ALL)
.title("list")
.border_type(BorderType::Rounded),
)
.style(Style::default().fg(Color::White))
.highlight_style(
Style::default()
.bg(Color::Rgb(183, 142, 241))
.add_modifier(Modifier::BOLD),
)
.highlight_symbol(">>");
f.render_stateful_widget(messages, top_chunks[0], &mut app.messages.state);
let block = Block::default()
.borders(Borders::ALL)
.title("info")
.border_type(BorderType::Rounded);
f.render_widget(block, top_chunks[1]);
let mut text = Text::from(Spans::from(msg));
text.patch_style(style);
let help_message = Paragraph::new(text);
f.render_widget(help_message, chunks[1]);
let input = Paragraph::new(app.input.as_ref())
.style(match app.input_mode {
InputMode::Normal => Style::default(),
InputMode::Editing => Style::default().fg(Color::Rgb(183, 142, 241)),
})
.block(Block::default().borders(Borders::all()).title("Input"));
f.render_widget(input, chunks[2]);
match app.input_mode {
InputMode::Normal =>
// Hide the cursor. `Frame` does this by default, so we don't need to do anything here
{}
InputMode::Editing => {
// Make the cursor visible and ask tui-rs to put it at the specified coordinates after rendering
f.set_cursor(
// Put cursor past the end of the input text
chunks[2].x + app.input.width() as u16 + 1,
// Move one line down, from the border to the input line
chunks[2].y + 1,
)
}
}
}

360
src/ln/ln.rs
View File

@@ -1,117 +1,13 @@
use crate::ln::open_text::{open_bat, open_glow};
use crate::ln::scraper::*;
use crate::ln::tracker::*;
use crate::ui::app::{app::KamiApp, ln::App};
use crossterm::{
event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
event::{DisableMouseCapture, EnableMouseCapture},
execute,
terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
};
use std::fs::File;
use std::io::Write;
use std::{error::Error, io};
use tui::{
backend::{Backend, CrosstermBackend},
layout::{Constraint, Direction, Layout},
style::{Color, Modifier, Style},
text::{Span, Spans, Text},
widgets::{Block, BorderType, Borders, List, ListItem, ListState, Paragraph},
Frame, Terminal,
};
use unicode_width::UnicodeWidthStr;
enum InputMode {
Normal,
Editing,
}
struct StatefulList<T> {
state: ListState,
items: Vec<T>,
}
impl<T> StatefulList<T> {
fn with_items(items: Vec<T>) -> StatefulList<T> {
StatefulList {
state: ListState::default(),
items,
}
}
fn next(&mut self) {
let i = match self.state.selected() {
Some(i) => {
if i >= self.items.len() - 1 {
0
} else {
i + 1
}
}
None => 0,
};
self.state.select(Some(i));
}
fn previous(&mut self) {
let i = match self.state.selected() {
Some(i) => {
if i == 0 {
self.items.len() - 1
} else {
i - 1
}
}
None => 0,
};
self.state.select(Some(i));
}
fn unselect(&mut self) {
self.state.select(None);
}
fn push(&mut self, item: T) {
self.items.push(item);
}
fn iter(&self) -> impl Iterator<Item = &T> {
self.items.iter()
}
}
struct App {
/// Current value of the input box
input: String,
/// Current input mode
input_mode: InputMode,
/// History of recorded messages
messages: StatefulList<String>,
ln_titles: Vec<String>,
ln_links: Vec<String>,
title: String,
ln_id: String,
ln_chapters: Vec<String>,
ln_chapters_links: Vec<String>,
last_page: String,
current_page: String,
current_page_number: u32,
}
impl<'a> App {
fn default() -> App {
App {
input: String::new(),
input_mode: InputMode::Normal,
messages: StatefulList::with_items(Vec::new()),
ln_titles: Vec::new(),
ln_links: Vec::new(),
title: String::new(),
ln_id: String::new(),
ln_chapters: Vec::new(),
ln_chapters_links: Vec::new(),
last_page: String::new(),
current_page: String::new(),
current_page_number: 0,
}
}
}
use tui::{backend::CrosstermBackend, Terminal};
pub fn ln_ui(chapter: u32, reader: String) -> Result<(), Box<dyn Error>> {
// setup terminal
@@ -123,14 +19,15 @@ pub fn ln_ui(chapter: u32, reader: String) -> Result<(), Box<dyn Error>> {
let mut terminal = Terminal::new(backend)?;
// create app and run it
let mut app = App::default();
let mut app = App::new();
app.reader = reader;
let chapter = chapter as f64;
app.current_page_number = 1;
if chapter != 0.0 {
app.current_page_number = (chapter / 48.0).ceil() as u32;
}
let res = run_app(&mut terminal, app, &*reader);
let res = app.run(&mut terminal);
// restore terminal
disable_raw_mode()?;
@@ -147,246 +44,3 @@ pub fn ln_ui(chapter: u32, reader: String) -> Result<(), Box<dyn Error>> {
Ok(())
}
fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: App, reader: &str) -> io::Result<()> {
let mut chapter_select = false;
loop {
terminal.draw(|f| ui(f, &mut app))?;
if let Event::Key(key) = event::read()? {
match app.input_mode {
InputMode::Normal => match key.code {
KeyCode::Char('i') => {
app.input_mode = InputMode::Editing;
}
KeyCode::Char('q') => {
terminal.clear()?;
return Ok(());
}
KeyCode::Left => app.messages.unselect(),
KeyCode::Char('h') => {
if app.current_page_number > 0 {
app.current_page_number -= 1;
}
app.current_page = get_ln_next_page(&app.ln_id, &app.current_page_number);
app.ln_chapters = get_ln_chapters(&app.current_page);
app.ln_chapters_links = get_ln_chapters_urls(&app.current_page);
app.messages.items.clear();
for chapter in app.ln_chapters.iter() {
app.messages.push(chapter.to_string());
}
}
KeyCode::Down => app.messages.next(),
KeyCode::Char('j') => app.messages.next(),
KeyCode::Up => app.messages.previous(),
KeyCode::Char('k') => app.messages.previous(),
KeyCode::Char('l') => {
if app.current_page_number < app.last_page.parse::<u32>().unwrap() {
app.current_page_number += 1;
}
app.current_page = get_ln_next_page(&app.ln_id, &app.current_page_number);
app.ln_chapters = get_ln_chapters(&app.current_page);
app.ln_chapters_links = get_ln_chapters_urls(&app.current_page);
app.messages.items.clear();
for chapter in app.ln_chapters.iter() {
app.messages.push(chapter.to_string());
}
}
//if KeyCode::Enter => {
KeyCode::Enter => {
if chapter_select == false {
let selected = app.messages.state.selected();
app.title = app
.messages
.iter()
.nth(selected.unwrap())
.unwrap()
.to_string();
if app.current_page_number == 1 {
let progress = get_ln_progress(&app.title);
app.current_page_number = progress.0;
app.messages.state.select(Some(progress.1));
}
let link = app.ln_links[selected.unwrap()].to_string();
let html = get_html(&link);
app.ln_id = get_ln_id(&html).to_string();
app.last_page = get_ln_last_page(&html);
app.current_page =
get_ln_next_page(&app.ln_id.to_string(), &app.current_page_number);
app.ln_chapters = get_ln_chapters(&app.current_page);
app.ln_chapters_links = get_ln_chapters_urls(&app.current_page);
app.messages.items.clear();
for chapter in app.ln_chapters.iter() {
app.messages.push(chapter.to_string());
}
chapter_select = true;
} else {
let selected = app.messages.state.selected();
let chapter_url = app.ln_chapters_links[selected.unwrap()].to_string();
let full_text = get_full_text(&chapter_url);
if cfg!(target_os = "windows") {
use dirs::home_dir;
let mut home = format!("{:?}", home_dir()).replace("\\\\", "/");
home.drain(0..6);
home.drain(home.len() - 2..home.len());
let mut file =
File::create(format!("{}/AppData/Roaming/log_e", home))
.expect("Unable to create file");
file.write_all(full_text.as_bytes())
.expect("Unable to write to file");
file.sync_all().expect("Unable to sync file");
} else {
let mut file =
File::create("/tmp/log_e").expect("Unable to create file");
file.write_all(full_text.as_bytes())
.expect("Unable to write to file");
file.sync_all().expect("Unable to sync file");
};
terminal.clear()?;
let _ = match reader {
"bat" => open_bat(),
"glow" => open_glow(),
&_ => todo!(),
};
write_ln_progress(
&app.title,
&app.current_page_number,
&app.messages.state.selected().unwrap(),
);
terminal.clear()?;
}
}
_ => {}
},
InputMode::Editing => match key.code {
KeyCode::Enter => {
//push app.input into app.messages with '1
let search: String = app.input.drain(..).collect();
let search = search.replace(" ", "+");
let url = "https://readlightnovels.net/?s=".to_string();
let url = format!("{}{}", url, search.trim()).trim().to_string();
let html = get_html(&url);
let ln_list = get_ln_list(html.as_str());
app.ln_titles = get_ln_titles(&ln_list);
app.ln_links = get_ln_urls(&ln_list);
app.messages.items.clear();
//remove index 0 of app.ln_titles and app.ln_links
app.ln_titles.remove(0);
app.ln_links.remove(0);
for ln in &app.ln_titles {
app.messages.push(ln.to_string());
}
chapter_select = false;
app.input_mode = InputMode::Normal;
}
KeyCode::Char(c) => {
app.input.push(c);
}
KeyCode::Backspace => {
app.input.pop();
}
KeyCode::Esc => {
app.input_mode = InputMode::Normal;
}
_ => {}
},
}
}
}
}
fn ui<B: Backend>(f: &mut Frame<B>, app: &mut App) {
let chunks = Layout::default()
.direction(Direction::Vertical)
.margin(1)
.constraints(
[
Constraint::Min(1),
Constraint::Length(1),
Constraint::Length(3),
]
.as_ref(),
)
.split(f.size());
let block = Block::default()
.borders(Borders::ALL)
.title("kami")
.border_type(BorderType::Rounded);
f.render_widget(block, f.size());
let (msg, style) = match app.input_mode {
InputMode::Normal => (
vec![
Span::raw("Press "),
Span::styled("q", Style::default().add_modifier(Modifier::BOLD)),
Span::raw(" to exit, "),
Span::styled("i", Style::default().add_modifier(Modifier::BOLD)),
Span::raw(" to search, "),
Span::styled("h", Style::default().add_modifier(Modifier::BOLD)),
Span::raw(" to go to the previous page, "),
Span::styled("l", Style::default().add_modifier(Modifier::BOLD)),
Span::raw(" to go to the next page."),
],
Style::default().add_modifier(Modifier::RAPID_BLINK),
),
InputMode::Editing => (
vec![
Span::raw("Press "),
Span::styled("Esc", Style::default().add_modifier(Modifier::BOLD)),
Span::raw(" to stop editing, "),
Span::styled("Enter", Style::default().add_modifier(Modifier::BOLD)),
Span::raw(" to select."),
],
Style::default(),
),
};
let messages: Vec<ListItem> = app
.messages
.iter()
.enumerate()
.map(|(i, m)| {
let content = vec![Spans::from(Span::raw(format!("{}: {}", i, m)))];
ListItem::new(content)
})
.collect();
let messages = List::new(messages)
.block(Block::default().borders(Borders::ALL).title("list"))
.style(Style::default().fg(Color::White))
.highlight_style(
Style::default()
.bg(Color::Rgb(183, 142, 241))
.add_modifier(Modifier::BOLD),
)
.highlight_symbol(">>");
f.render_stateful_widget(messages, chunks[0], &mut app.messages.state);
let mut text = Text::from(Spans::from(msg));
text.patch_style(style);
let help_message = Paragraph::new(text);
f.render_widget(help_message, chunks[1]);
let input = Paragraph::new(app.input.as_ref())
.style(match app.input_mode {
InputMode::Normal => Style::default(),
InputMode::Editing => Style::default().fg(Color::Rgb(183, 142, 241)),
})
.block(Block::default().borders(Borders::all()).title("Input"));
f.render_widget(input, chunks[2]);
match app.input_mode {
InputMode::Normal =>
// Hide the cursor. `Frame` does this by default, so we don't need to do anything here
{}
InputMode::Editing => {
// Make the cursor visible and ask tui-rs to put it at the specified coordinates after rendering
f.set_cursor(
// Put cursor past the end of the input text
chunks[2].x + app.input.width() as u16 + 1,
// Move one line down, from the border to the input line
chunks[2].y + 1,
)
}
}
}

1
src/main.rs
View File

@@ -1,6 +1,7 @@
mod anime;
mod helpers;
mod ln;
mod ui;
use anime::anime::anime_ui;
use colored::Colorize;

390
src/ui/app/anime.rs Normal file
View File

@@ -0,0 +1,390 @@
use crate::ui::{app::app::KamiApp, input::InputMode, list::StatefulList};
use crate::anime::player::{open_cast, open_video};
use crate::anime::scraper::{get_anime_info, get_anime_link, get_animes, get_image};
use crate::anime::trackers::{
get_an_history, get_an_progress, get_anime_id, get_user_anime_progress, update_anime_progress,
write_an_progress,
};
use crossterm::event::{self, Event, KeyCode};
use std::io;
use tui::{
backend::Backend,
layout::{Constraint, Direction, Layout},
style::{Color, Modifier, Style},
text::{Span, Spans, Text},
widgets::{Block, BorderType, Borders, List, ListItem, Paragraph},
Frame, Terminal,
};
use unicode_width::UnicodeWidthStr;
use viuer::{print_from_file, terminal_size, Config};
pub struct App {
/// Current value of the input box
input: String,
animes: (Vec<String>, Vec<String>, Vec<String>),
image: String,
/// Current input mode
input_mode: InputMode,
/// History of recorded messages
messages: StatefulList<String>,
title: String,
link: String,
ep: u64,
progress: i32,
anime_id: i32,
pub token: String,
pub provider: String,
pub cast: (bool, String),
}
impl<'a> KamiApp for App {
fn new() -> Self {
App {
input: String::new(),
animes: get_an_history(),
image: String::new(),
input_mode: InputMode::Normal,
messages: StatefulList::with_items(Vec::new()),
title: String::new(),
link: String::new(),
ep: 0,
progress: 0,
anime_id: 0,
token: String::new(),
provider: String::new(),
cast: (false, "0".to_string()),
}
}
fn run<B: Backend>(&mut self, terminal: &mut Terminal<B>) -> io::Result<()> {
let mut ep_select = false;
fn change_image(app: &App) {
//save as f32
let (width, height) = terminal_size().to_owned();
let width = width as f32;
let height = height as f32;
let sixel_support = viuer::is_sixel_supported();
let config = match sixel_support {
true => Config {
x: ((width / 2.0) + 1.0).round() as u16,
y: 2,
width: Some((width / 1.3).round() as u32),
height: Some((height * 1.5) as u32),
restore_cursor: true,
..Default::default()
},
false => Config {
x: ((width / 2.0) + 1.0).round() as u16,
y: 2,
width: Some(((width / 2.0) - 4.0).round() as u32),
height: Some((height / 1.3).round() as u32),
restore_cursor: true,
..Default::default()
},
};
let config_path = dirs::config_dir().unwrap().join("kami");
let image_path = config_path.join("tmp.jpg");
get_image(&app.image, &image_path.to_str().unwrap());
print_from_file(image_path, &config).expect("Image printing failed.");
}
self.messages.items.clear();
for anime in &self.animes.1 {
self.messages.push(anime.to_string());
}
self.input_mode = InputMode::Normal;
loop {
terminal.draw(|f| self.ui(f))?;
if let Event::Key(key) = event::read()? {
match self.input_mode {
InputMode::Normal => match key.code {
KeyCode::Char('i') => {
self.input_mode = InputMode::Editing;
}
KeyCode::Char('q') => {
return Ok(());
}
KeyCode::Left => self.messages.unselect(),
KeyCode::Char('h') => self.messages.unselect(),
KeyCode::Char('g') => self.messages.begin(),
KeyCode::Char('G') => self.messages.end(),
KeyCode::Down => match ep_select {
true => {
self.messages.next();
}
false => {
self.messages.next();
let selected = self.messages.state.selected();
self.image = self.animes.2[selected.unwrap()].clone();
change_image(&self);
}
},
KeyCode::Char('j') => match ep_select {
true => {
self.messages.next();
}
false => {
self.messages.next();
let selected = self.messages.state.selected();
self.image = self.animes.2[selected.unwrap()].clone();
change_image(&self);
}
},
KeyCode::Up => match ep_select {
true => {
self.messages.previous();
}
false => {
self.messages.previous();
let selected = self.messages.state.selected();
self.image = self.animes.2[selected.unwrap()].clone();
change_image(&self);
}
},
KeyCode::Char('k') => match ep_select {
true => {
self.messages.previous();
}
false => {
self.messages.previous();
let selected = self.messages.state.selected();
self.image = self.animes.2[selected.unwrap()].clone();
change_image(&self);
}
},
//if KeyCode::Enter => {
KeyCode::Enter => {
if ep_select == false {
self.progress = 0;
let selected = self.messages.state.selected();
self.title = self.messages.items[selected.unwrap()].clone();
self.link = self.animes.0[selected.unwrap()].clone();
let anime_info = get_anime_info(&self.animes.0[selected.unwrap()]);
self.anime_id = get_anime_id(anime_info.0);
self.messages.items.clear();
if self.token == "local" || self.anime_id == 0 {
self.progress = get_an_progress(&self.title) as i32;
self.messages.state.select(Some(self.progress as usize));
} else {
self.progress =
get_user_anime_progress(self.anime_id, self.token.as_str());
self.messages.state.select(Some(self.progress as usize));
}
if anime_info.1 == 1 {
let link = get_anime_link(&self.link, 1);
if !self.cast.0 {
open_video((link, format!("{} Episode 1", &self.title)));
} else {
open_cast(
(link, format!("{} Episode 1", &self.title)),
&self.cast.1,
)
}
let selected = self.messages.state.selected();
let image_url = self.animes.2[selected.unwrap()].clone();
if self.token == "local" || self.anime_id == 0 {
write_an_progress(
(&self.title, &self.link, &image_url),
&1,
);
} else {
update_anime_progress(
self.anime_id,
1,
self.token.as_str(),
);
write_an_progress(
(&self.title, &self.link, &image_url),
&1,
);
}
} else {
for ep in 1..anime_info.1 + 1 {
self.messages.push(format!("Episode {}", ep));
}
ep_select = true;
}
} else {
let selected = self.messages.state.selected();
self.ep = self
.messages
.iter()
.nth(selected.unwrap())
.unwrap()
.replace("Episode ", "")
.parse::<u64>()
.unwrap();
let link = get_anime_link(&self.link, self.ep);
if !self.cast.0 {
open_video((
link,
format!("{} Episode {}", &self.title, self.ep),
));
} else {
open_cast(
(link, format!("{} Episode {}", &self.title, self.ep)),
&self.cast.1,
)
}
let image_url = &self.image;
if self.ep > self.progress as u64 {
if self.token == "local" || self.anime_id == 0 {
write_an_progress(
(&self.title, &self.link, &image_url),
&self.ep,
);
} else {
update_anime_progress(
self.anime_id,
self.ep as usize,
self.token.as_str(),
);
write_an_progress(
(&self.title, &self.link, &image_url),
&self.ep,
);
}
self.progress = self.ep as i32;
}
}
}
_ => {}
},
InputMode::Editing => match key.code {
KeyCode::Enter => {
//push self.input into self.messages with '
self.animes = get_animes(self.input.drain(..).collect());
self.messages.items.clear();
for anime in &self.animes.1 {
self.messages.push(anime.to_string());
}
ep_select = false;
self.input_mode = InputMode::Normal;
}
KeyCode::Char(c) => {
self.input.push(c);
}
KeyCode::Backspace => {
self.input.pop();
}
KeyCode::Esc => {
self.input_mode = InputMode::Normal;
}
_ => {}
},
}
}
}
}
fn ui<B: Backend>(&mut self, f: &mut Frame<B>) {
let chunks = Layout::default()
.direction(Direction::Vertical)
.margin(1)
.constraints(
[
Constraint::Min(1),
Constraint::Length(1),
Constraint::Length(3),
]
.as_ref(),
)
.split(f.size());
let block = Block::default()
.borders(Borders::ALL)
.title("kami")
.border_type(BorderType::Rounded);
f.render_widget(block, f.size());
let top_chunks = Layout::default()
.direction(Direction::Horizontal)
.constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
.split(chunks[0]);
let (msg, style) = match self.input_mode {
InputMode::Normal => (
vec![
Span::raw("Press "),
Span::styled("q", Style::default().add_modifier(Modifier::BOLD)),
Span::raw(" to exit, "),
Span::styled("i", Style::default().add_modifier(Modifier::BOLD)),
Span::raw(" to search."),
],
Style::default().add_modifier(Modifier::RAPID_BLINK),
),
InputMode::Editing => (
vec![
Span::raw("Press "),
Span::styled("Esc", Style::default().add_modifier(Modifier::BOLD)),
Span::raw(" to stop editing, "),
Span::styled("Enter", Style::default().add_modifier(Modifier::BOLD)),
Span::raw(" to select."),
],
Style::default(),
),
};
let messages: Vec<ListItem> = self
.messages
.iter()
.enumerate()
.map(|(i, m)| {
let content = vec![Spans::from(Span::raw(format!("{}: {}", i, m)))];
ListItem::new(content)
})
.collect();
let messages = List::new(messages)
.block(
Block::default()
.borders(Borders::ALL)
.title("list")
.border_type(BorderType::Rounded),
)
.style(Style::default().fg(Color::White))
.highlight_style(
Style::default()
.bg(Color::Rgb(183, 142, 241))
.add_modifier(Modifier::BOLD),
)
.highlight_symbol(">>");
f.render_stateful_widget(messages, top_chunks[0], &mut self.messages.state);
let block = Block::default()
.borders(Borders::ALL)
.title("info")
.border_type(BorderType::Rounded);
f.render_widget(block, top_chunks[1]);
let mut text = Text::from(Spans::from(msg));
text.patch_style(style);
let help_message = Paragraph::new(text);
f.render_widget(help_message, chunks[1]);
let input = Paragraph::new(self.input.as_ref())
.style(match self.input_mode {
InputMode::Normal => Style::default(),
InputMode::Editing => Style::default().fg(Color::Rgb(183, 142, 241)),
})
.block(Block::default().borders(Borders::all()).title("Input"));
f.render_widget(input, chunks[2]);
match self.input_mode {
InputMode::Normal =>
// Hide the cursor. `Frame` does this by default, so we don't need to do anything here
{}
InputMode::Editing => {
// Make the cursor visible and ask tui-rs to put it at the specified coordinates after rendering
f.set_cursor(
// Put cursor past the end of the input text
chunks[2].x + self.input.width() as u16 + 1,
// Move one line down, from the border to the input line
chunks[2].y + 1,
)
}
}
}
}

8
src/ui/app/app.rs Normal file
View File

@@ -0,0 +1,8 @@
use std::io;
use tui::{backend::Backend, Frame, Terminal};
pub trait KamiApp {
fn new() -> Self;
fn run<B: Backend>(&mut self, terminal: &mut Terminal<B>) -> io::Result<()>;
fn ui<B: Backend>(&mut self, f: &mut Frame<B>);
}

307
src/ui/app/ln.rs Normal file
View File

@@ -0,0 +1,307 @@
use crate::ui::{app::app::KamiApp, input::InputMode, list::StatefulList};
use crate::ln::open_text::{open_bat, open_glow};
use crate::ln::scraper::*;
use crate::ln::tracker::*;
use crossterm::event::{self, Event, KeyCode};
use std::fs::File;
use std::io;
use std::io::Write;
use tui::{
backend::Backend,
layout::{Constraint, Direction, Layout},
style::{Color, Modifier, Style},
text::{Span, Spans, Text},
widgets::{Block, BorderType, Borders, List, ListItem, Paragraph},
Frame, Terminal,
};
use unicode_width::UnicodeWidthStr;
pub struct App {
input: String, // Input box's value
input_mode: InputMode,
messages: StatefulList<String>, // History of recorded messages
ln_titles: Vec<String>,
ln_links: Vec<String>,
title: String,
ln_id: String,
ln_chapters: Vec<String>,
ln_chapters_links: Vec<String>,
last_page: String,
current_page: String,
pub current_page_number: u32,
pub reader: String,
}
impl<'a> KamiApp for App {
fn new() -> Self {
App {
input: String::new(),
input_mode: InputMode::Normal,
messages: StatefulList::with_items(Vec::new()),
ln_titles: Vec::new(),
ln_links: Vec::new(),
title: String::new(),
ln_id: String::new(),
ln_chapters: Vec::new(),
ln_chapters_links: Vec::new(),
last_page: String::new(),
current_page: String::new(),
current_page_number: 0,
reader: "bat".to_string(),
}
}
fn run<B: Backend>(&mut self, terminal: &mut Terminal<B>) -> io::Result<()> {
let mut chapter_select = false;
loop {
terminal.draw(|f| self.ui(f))?;
if let Event::Key(key) = event::read()? {
match self.input_mode {
InputMode::Normal => match key.code {
KeyCode::Char('i') => {
self.input_mode = InputMode::Editing;
}
KeyCode::Char('q') => {
terminal.clear()?;
return Ok(());
}
KeyCode::Left => self.messages.unselect(),
KeyCode::Char('g') => self.messages.begin(),
KeyCode::Char('G') => self.messages.end(),
KeyCode::Down => self.messages.next(),
KeyCode::Char('j') => self.messages.next(),
KeyCode::Up => self.messages.previous(),
KeyCode::Char('k') => self.messages.previous(),
KeyCode::Char('h') => {
if self.current_page_number > 0 {
self.current_page_number -= 1;
}
self.current_page =
get_ln_next_page(&self.ln_id, &self.current_page_number);
self.ln_chapters = get_ln_chapters(&self.current_page);
self.ln_chapters_links = get_ln_chapters_urls(&self.current_page);
self.messages.items.clear();
for chapter in self.ln_chapters.iter() {
self.messages.push(chapter.to_string());
}
}
KeyCode::Char('l') => {
if self.current_page_number < self.last_page.parse::<u32>().unwrap() {
self.current_page_number += 1;
}
self.current_page =
get_ln_next_page(&self.ln_id, &self.current_page_number);
self.ln_chapters = get_ln_chapters(&self.current_page);
self.ln_chapters_links = get_ln_chapters_urls(&self.current_page);
self.messages.items.clear();
for chapter in self.ln_chapters.iter() {
self.messages.push(chapter.to_string());
}
}
//if KeyCode::Enter => {
KeyCode::Enter => {
if chapter_select == false {
let selected = self.messages.state.selected();
self.title = self
.messages
.iter()
.nth(selected.unwrap())
.unwrap()
.to_string();
if self.current_page_number == 1 {
let progress = get_ln_progress(&self.title);
self.current_page_number = progress.0;
self.messages.state.select(Some(progress.1));
}
let link = self.ln_links[selected.unwrap()].to_string();
let html = get_html(&link);
self.ln_id = get_ln_id(&html).to_string();
self.last_page = get_ln_last_page(&html);
self.current_page = get_ln_next_page(
&self.ln_id.to_string(),
&self.current_page_number,
);
self.ln_chapters = get_ln_chapters(&self.current_page);
self.ln_chapters_links = get_ln_chapters_urls(&self.current_page);
self.messages.items.clear();
for chapter in self.ln_chapters.iter() {
self.messages.push(chapter.to_string());
}
chapter_select = true;
} else {
let selected = self.messages.state.selected();
let chapter_url =
self.ln_chapters_links[selected.unwrap()].to_string();
let full_text = get_full_text(&chapter_url);
if cfg!(target_os = "windows") {
use dirs::home_dir;
let mut home = format!("{:?}", home_dir()).replace("\\\\", "/");
home.drain(0..6);
home.drain(home.len() - 2..home.len());
let mut file =
File::create(format!("{}/AppData/Roaming/log_e", home))
.expect("Unable to create file");
file.write_all(full_text.as_bytes())
.expect("Unable to write to file");
file.sync_all().expect("Unable to sync file");
} else {
let mut file =
File::create("/tmp/log_e").expect("Unable to create file");
file.write_all(full_text.as_bytes())
.expect("Unable to write to file");
file.sync_all().expect("Unable to sync file");
};
terminal.clear()?;
let _ = match &*self.reader {
"bat" => open_bat(),
"glow" => open_glow(),
&_ => todo!(),
};
write_ln_progress(
&self.title,
&self.current_page_number,
&self.messages.state.selected().unwrap(),
);
terminal.clear()?;
}
}
_ => {}
},
InputMode::Editing => match key.code {
KeyCode::Enter => {
//push self.input into self.messages with '1
let search: String = self.input.drain(..).collect();
let search = search.replace(" ", "+");
let url = "https://readlightnovels.net/?s=".to_string();
let url = format!("{}{}", url, search.trim()).trim().to_string();
let html = get_html(&url);
let ln_list = get_ln_list(html.as_str());
self.ln_titles = get_ln_titles(&ln_list);
self.ln_links = get_ln_urls(&ln_list);
self.messages.items.clear();
//remove index 0 of self.ln_titles and self.ln_links
self.ln_titles.remove(0);
self.ln_links.remove(0);
for ln in &self.ln_titles {
self.messages.push(ln.to_string());
}
chapter_select = false;
self.input_mode = InputMode::Normal;
}
KeyCode::Char(c) => {
self.input.push(c);
}
KeyCode::Backspace => {
self.input.pop();
}
KeyCode::Esc => {
self.input_mode = InputMode::Normal;
}
_ => {}
},
}
}
}
}
fn ui<B: Backend>(&mut self, f: &mut Frame<B>) {
let chunks = Layout::default()
.direction(Direction::Vertical)
.margin(1)
.constraints(
[
Constraint::Min(1),
Constraint::Length(1),
Constraint::Length(3),
]
.as_ref(),
)
.split(f.size());
let block = Block::default()
.borders(Borders::ALL)
.title("kami")
.border_type(BorderType::Rounded);
f.render_widget(block, f.size());
let (msg, style) = match self.input_mode {
InputMode::Normal => (
vec![
Span::raw("Press "),
Span::styled("q", Style::default().add_modifier(Modifier::BOLD)),
Span::raw(" to exit, "),
Span::styled("i", Style::default().add_modifier(Modifier::BOLD)),
Span::raw(" to search, "),
Span::styled("h", Style::default().add_modifier(Modifier::BOLD)),
Span::raw(" to go to the previous page, "),
Span::styled("l", Style::default().add_modifier(Modifier::BOLD)),
Span::raw(" to go to the next page."),
],
Style::default().add_modifier(Modifier::RAPID_BLINK),
),
InputMode::Editing => (
vec![
Span::raw("Press "),
Span::styled("Esc", Style::default().add_modifier(Modifier::BOLD)),
Span::raw(" to stop editing, "),
Span::styled("Enter", Style::default().add_modifier(Modifier::BOLD)),
Span::raw(" to select."),
],
Style::default(),
),
};
let messages: Vec<ListItem> = self
.messages
.iter()
.enumerate()
.map(|(i, m)| {
let content = vec![Spans::from(Span::raw(format!("{}: {}", i, m)))];
ListItem::new(content)
})
.collect();
let messages = List::new(messages)
.block(Block::default().borders(Borders::ALL).title("list"))
.style(Style::default().fg(Color::White))
.highlight_style(
Style::default()
.bg(Color::Rgb(183, 142, 241))
.add_modifier(Modifier::BOLD),
)
.highlight_symbol(">>");
f.render_stateful_widget(messages, chunks[0], &mut self.messages.state);
let mut text = Text::from(Spans::from(msg));
text.patch_style(style);
let help_message = Paragraph::new(text);
f.render_widget(help_message, chunks[1]);
let input = Paragraph::new(self.input.as_ref())
.style(match self.input_mode {
InputMode::Normal => Style::default(),
InputMode::Editing => Style::default().fg(Color::Rgb(183, 142, 241)),
})
.block(Block::default().borders(Borders::all()).title("Input"));
f.render_widget(input, chunks[2]);
match self.input_mode {
InputMode::Normal =>
// Hide the cursor. `Frame` does this by default, so we don't need to do anything here
{}
InputMode::Editing => {
// Make the cursor visible and ask tui-rs to put it at the specified coordinates after rendering
f.set_cursor(
// Put cursor past the end of the input text
chunks[2].x + self.input.width() as u16 + 1,
// Move one line down, from the border to the input line
chunks[2].y + 1,
)
}
}
}
}

3
src/ui/app/mod.rs Normal file
View File

@@ -0,0 +1,3 @@
pub mod anime;
pub mod app;
pub mod ln;

4
src/ui/input.rs Normal file
View File

@@ -0,0 +1,4 @@
pub enum InputMode {
Normal,
Editing,
}

61
src/ui/list.rs Normal file
View File

@@ -0,0 +1,61 @@
use tui::widgets::ListState;
pub struct StatefulList<T> {
pub state: ListState,
pub items: Vec<T>,
}
impl<T> StatefulList<T> {
pub fn with_items(items: Vec<T>) -> StatefulList<T> {
StatefulList {
state: ListState::default(),
items,
}
}
pub fn begin(&mut self) {
self.state.select(Some(0))
}
pub fn end(&mut self) {
self.state.select(Some(self.items.len() - 1))
}
pub fn next(&mut self) {
let i = match self.state.selected() {
Some(i) => {
if i == self.items.len() - 1 {
0
} else {
i + 1
}
}
None => 0,
};
self.state.select(Some(i));
}
pub fn previous(&mut self) {
let i = match self.state.selected() {
Some(i) => {
if i == 0 {
self.items.len() - 1
} else {
i - 1
}
}
None => 0,
};
self.state.select(Some(i));
}
pub fn unselect(&mut self) {
self.state.select(None);
}
pub fn push(&mut self, item: T) {
self.items.push(item);
}
pub fn iter(&self) -> impl Iterator<Item = &T> {
self.items.iter()
}
}

3
src/ui/mod.rs Normal file
View File

@@ -0,0 +1,3 @@
pub mod app;
pub mod input;
pub mod list;