157 lines
4 KiB
Rust
157 lines
4 KiB
Rust
use std::{env, fs, io, path::PathBuf};
|
|
|
|
use crossterm::event::{self, Event, KeyCode, KeyEvent, KeyEventKind};
|
|
use ratatui::{
|
|
DefaultTerminal, Frame,
|
|
buffer::Buffer,
|
|
layout::Rect,
|
|
style::{Color, Stylize},
|
|
widgets::{Block, Borders, List, ListState, Padding, StatefulWidget},
|
|
};
|
|
|
|
struct App<'a> {
|
|
window: Window<'a>,
|
|
exit: bool,
|
|
}
|
|
|
|
impl App<'_> {
|
|
fn run(&mut self, terminal: &mut DefaultTerminal) -> io::Result<()> {
|
|
while !self.exit {
|
|
terminal.draw(|frame| self.draw(frame))?;
|
|
self.handle_events()?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn draw(&mut self, frame: &mut Frame) {
|
|
self.window.render(frame.area(), frame.buffer_mut());
|
|
}
|
|
|
|
fn handle_events(&mut self) -> io::Result<()> {
|
|
match event::read()? {
|
|
Event::Key(key_event) if key_event.kind == KeyEventKind::Press => {
|
|
self.handle_key_events(key_event)
|
|
}
|
|
|
|
_ => {}
|
|
};
|
|
Ok(())
|
|
}
|
|
|
|
fn handle_key_events(&mut self, key_event: KeyEvent) {
|
|
match key_event.code {
|
|
KeyCode::Char('q') | KeyCode::Esc => self.exit(),
|
|
KeyCode::Down => self.window.state.select_next(),
|
|
KeyCode::Up => self.window.state.select_previous(),
|
|
KeyCode::Left => {
|
|
self.window.absolute_path.pop();
|
|
self.window.update();
|
|
}
|
|
KeyCode::Right => match self.window.state.selected() {
|
|
Some(val) => {
|
|
self.window
|
|
.absolute_path
|
|
.push(self.window.prepare_updated_list()[val].clone());
|
|
self.window.update();
|
|
}
|
|
None => {
|
|
print!("hello");
|
|
}
|
|
},
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
fn exit(&mut self) {
|
|
self.exit = true;
|
|
}
|
|
}
|
|
|
|
struct Window<'a> {
|
|
widget: WindowWidget<'a>,
|
|
absolute_path: PathBuf,
|
|
state: ListState,
|
|
}
|
|
|
|
impl Window<'_> {
|
|
fn new(absolute_path: PathBuf) -> Self {
|
|
Window {
|
|
widget: WindowWidget::new(Self::prepare_list(&absolute_path)),
|
|
absolute_path,
|
|
state: ListState::default().with_selected(Some(0)),
|
|
}
|
|
}
|
|
|
|
fn render(&mut self, area: Rect, buf: &mut Buffer) {
|
|
self.widget.render(area, buf, &mut self.state);
|
|
}
|
|
|
|
fn prepare_list(absolute_path: &PathBuf) -> Vec<String> {
|
|
match fs::read_dir(absolute_path) {
|
|
Ok(val) => {
|
|
let mut the_list: Vec<String> = Vec::new();
|
|
|
|
for item in val {
|
|
the_list.push(item.unwrap().path().display().to_string());
|
|
}
|
|
|
|
return the_list;
|
|
}
|
|
Err(err) => {}
|
|
}
|
|
}
|
|
|
|
fn prepare_updated_list(&self) -> Vec<String> {
|
|
Self::prepare_list(&self.absolute_path)
|
|
}
|
|
|
|
fn update(&mut self) {
|
|
self.widget.update(self.prepare_updated_list());
|
|
}
|
|
}
|
|
|
|
struct WindowWidget<'a> {
|
|
list: List<'a>,
|
|
}
|
|
|
|
impl WindowWidget<'_> {
|
|
fn update(&mut self, prepared_list: Vec<String>) {
|
|
let block = Block::new()
|
|
.borders(Borders::ALL)
|
|
.padding(Padding::symmetric(1, 1))
|
|
.fg(Color::Blue);
|
|
|
|
self.list = List::new(prepared_list)
|
|
.block(block)
|
|
.highlight_style(Color::Cyan);
|
|
}
|
|
|
|
fn new(prepared_list: Vec<String>) -> Self {
|
|
let mut window_widget = WindowWidget {
|
|
list: List::new(Vec::<String>::new()),
|
|
};
|
|
|
|
window_widget.update(prepared_list);
|
|
window_widget
|
|
}
|
|
}
|
|
|
|
impl StatefulWidget for &mut WindowWidget<'_> {
|
|
type State = ListState;
|
|
|
|
fn render(self, area: Rect, buf: &mut Buffer, state: &mut ListState) {
|
|
StatefulWidget::render(&self.list, area, buf, state);
|
|
}
|
|
}
|
|
|
|
fn main() -> io::Result<()> {
|
|
let mut terminal = ratatui::init();
|
|
let dir = Window::new(env::current_dir().unwrap());
|
|
let app_result = App {
|
|
window: dir,
|
|
exit: false,
|
|
}
|
|
.run(&mut terminal);
|
|
ratatui::restore();
|
|
app_result
|
|
}
|