Commit a0582ea

rmptuia0582ea

get basic tui working with Ratatui

Author: krolxon
Date: 2024-04-23 16:10 +0530
Parent: a0a3139
Commit: a0582ead78fda02e4137a82e100963e88362f252

+942 −57

13 files changed

Browse files Patch

−Context 3+

M Cargo.lock +482 −11
M Cargo.toml +2 −0
A src/app.rs +61 −0
M src/cli.rs +22 −22
M src/connection.rs +38 −8
A src/error.rs +6 −0
A src/event.rs +79 −0
A src/handler.rs +47 −0
A src/lib.rs +23 −0
A src/list.rs +24 −0
M src/main.rs +55 −16
A src/tui.rs +66 −0
A src/ui.rs +37 −0

M Cargo.lock View

M Cargo.toml View

A src/app.rs View

M src/cli.rs View

M src/connection.rs View

A src/error.rs View

A src/event.rs View

A src/handler.rs View

A src/lib.rs View

A src/list.rs View

M src/main.rs View

A src/tui.rs View

A src/ui.rs View

	@@ -0,0 +1,61 @@
1	+	use crate::connection::Connection;
2	+	use crate::list::ContentList;
3	+	use std::collections::VecDeque;
4	+
5	+	// Application result type
6	+	pub type AppResult<T> = std::result::Result<T, Box<dyn std::error::Error>>;
7	+
8	+	/// Application
9	+	#[derive(Debug)]
10	+	pub struct App {
11	+	/// check if app is running
12	+	pub running: bool,
13	+	pub conn: Connection,
14	+	pub play_deque: VecDeque<String>,
15	+	pub list: ContentList,
16	+	}
17	+
18	+	impl App {
19	+	pub fn new(addrs: &str) -> Self {
20	+	let mut conn = Connection::new(addrs).unwrap();
21	+	let mut vec: VecDeque<String> = VecDeque::new();
22	+	Self::get_queue(&mut conn, &mut vec);
23	+	Self {
24	+	running: true,
25	+	conn,
26	+	play_deque: vec,
27	+	list: ContentList::new(),
28	+	}
29	+	}
30	+
31	+	pub fn tick(&self) {}
32	+
33	+	pub fn quit(&mut self) {
34	+	self.running = false;
35	+	}
36	+
37	+	pub fn get_queue(conn: &mut Connection, vec: &mut VecDeque<String>) {
38	+	conn.conn.queue().unwrap().into_iter().for_each(\|x\| {
39	+	if let Some(title) = x.title {
40	+	if let Some(artist) = x.artist {
41	+	vec.push_back(format!("{} - {}", artist, title));
42	+	} else {
43	+	vec.push_back(title)
44	+	}
45	+	} else {
46	+	vec.push_back(x.file)
47	+	}
48	+	});
49	+	}
50	+
51	+	pub fn update_queue(&mut self) {
52	+	self.play_deque.clear();
53	+	Self::get_queue(&mut self.conn, &mut self.play_deque);
54	+	}
55	+	}
56	+
57	+	fn to_vecdeque(filenames: &Vec<String>) -> VecDeque<String> {
58	+	let mut v: VecDeque<String> = VecDeque::new();
59	+	v = filenames.iter().map(\|x\| x.to_string()).collect();
60	+	v
61	+	}

		@@ -1,28 +1,12 @@
1	1		use clap::{Parser, Subcommand};
	2	+
2	3		#[derive(Parser, Debug)]
3		−	#[command(version, about)]
4		−	#[clap(author = "krolyxon")]
	4	+	#[clap(version, about, author = "krolyxon")]
5	5		/// MPD client made with Rust
6	6		pub struct Args {
7		−	/// pause
8		−	#[clap(short, long, default_value = "false")]
9		−	pub pause: bool,
10		−
11		−	/// toggle pause
12		−	#[arg(short, long, default_value = "false")]
13		−	pub toggle_pause: bool,
14		−
15		−	/// show current status
16		−	#[arg(short, long, default_value = "false")]
17		−	pub show_status: bool,
18		−
19		−	/// use fzf selector for selecting songs
20		−	#[arg(short, long, default_value = "false")]
21		−	pub fzf_select: bool,
22		−
23		−	/// use dmenu selector for selecting songss
24		−	#[arg(short, long, default_value = "false")]
25		−	pub dmenu_select: bool,
	7	+	/// No TUI
	8	+	#[arg(short= 'n', default_value="false")]
	9	+	pub no_tui: bool,
26	10
27	11		#[command(subcommand)]
28	12		pub command: Command,
		@@ -30,14 +14,30 @@ pub struct Args {
30	14
31	15		#[derive(Debug, Subcommand)]
32	16		pub enum Command {
33		−	#[command(arg_required_else_help = true)]
	17	+	#[command(arg_required_else_help = true, long_flag = "volume" , short_flag = 'v')]
	18	+	/// Set Volume
34	19		Volume {
35	20		vol: String,
36	21		},
37	22
	23	+	/// Use dmenu for selection
	24	+	#[command(long_flag = "dmenu" , short_flag = 'd')]
38	25		Dmenu,
	26	+
	27	+	/// Use Fzf for selection
	28	+	#[command(long_flag = "fzf" , short_flag = 'f')]
39	29		Fzf,
	30	+
	31	+	/// Check Status
	32	+	#[command(long_flag = "status" , short_flag = 's')]
40	33		Status,
	34	+
	35	+	/// Pause playback
	36	+	#[command(long_flag = "pause" , short_flag = 'p')]
41	37		Pause,
	38	+
	39	+	/// Toggle Playback
	40	+	#[command(long_flag = "toggle" , short_flag = 't')]
42	41		Toggle,
	42	+
43	43		}

		@@ -1,15 +1,20 @@
1	1		use mpd::song::Song;
2	2		use mpd::{Client, State};
3	3		use simple_dmenu::dmenu;
	4	+	use std::process::Command;
4	5
	6	+	pub type Result<T> = core::result::Result<T, Error>;
	7	+	pub type Error = Box<dyn std::error::Error>;
	8	+
	9	+	#[derive(Debug)]
5	10		pub struct Connection {
6	11		pub conn: Client,
7	12		pub songs_filenames: Vec<String>,
8	13		}
9	14
10	15		impl Connection {
11		−	pub fn new(addrs: &str) -> Result<Self, mpd::error::Error> {
12		−	let mut conn = Client::connect(addrs)?;
	16	+	pub fn new(addrs: &str) -> Result<Self> {
	17	+	let mut conn = Client::connect(addrs).unwrap();
13	18		let songs_filenames: Vec<String> = conn
14	19		.listall()
15	20		.unwrap()
		@@ -23,23 +28,29 @@ impl Connection {
23	28		})
24	29		}
25	30
26		−	pub fn play_fzf(&mut self) {
	31	+	pub fn play_fzf(&mut self) -> Result<()> {
	32	+	is_installed("fzf").map_err(\|ex\| ex)?;
	33	+
27	34		let ss = &self.songs_filenames;
28	35		let fzf_choice = rust_fzf::select(ss.clone(), Vec::new()).unwrap();
29	36		let index = get_choice_index(&self.songs_filenames, fzf_choice.get(0).unwrap());
30	37		let song = self.get_song_with_only_filename(ss.get(index).unwrap());
31		−	self.push(&song);
	38	+	self.push(&song)?;
	39	+
	40	+	Ok(())
32	41		}
33	42
34		−	pub fn play_dmenu(&mut self) {
	43	+	pub fn play_dmenu(&mut self) -> Result<()> {
	44	+	is_installed("dmenu").map_err(\|ex\| ex)?;
35	45		let ss: Vec<&str> = self.songs_filenames.iter().map(\|x\| x.as_str()).collect();
36	46		let op = dmenu!(iter &ss; args "-l", "30");
37	47		let index = get_choice_index(&self.songs_filenames, &op);
38	48		let song = self.get_song_with_only_filename(ss.get(index).unwrap());
39		−	self.push(&song);
	49	+	self.push(&song)?;
	50	+	Ok(())
40	51		}
41	52
42		−	fn push(&mut self, song: &Song) {
	53	+	pub fn push(&mut self, song: &Song) -> Result<()> {
43	54		if self.conn.queue().unwrap().is_empty() {
44	55		self.conn.push(song).unwrap();
45	56		self.conn.play().unwrap();
		@@ -50,9 +61,11 @@ impl Connection {
50	61		}
51	62		self.conn.next().unwrap();
52	63		}
	64	+
	65	+	Ok(())
53	66		}
54	67
55		−	fn get_song_with_only_filename(&self, filename: &str) -> Song {
	68	+	pub fn get_song_with_only_filename(&self, filename: &str) -> Song {
56	69		Song {
57	70		file: filename.to_string(),
58	71		artist: None,
		@@ -66,6 +79,10 @@ impl Connection {
66	79		}
67	80		}
68	81
	82	+	pub fn get_current_song(&mut self) -> Option<String> {
	83	+	self.conn.currentsong().unwrap().unwrap_or_default().title
	84	+
	85	+	}
69	86		pub fn status(&mut self) {
70	87		let current_song = self.conn.currentsong();
71	88		let status = self.conn.status().unwrap();
		@@ -112,3 +129,16 @@ fn get_choice_index(ss: &Vec<String>, selection: &str) -> usize {
112	129
113	130		choice
114	131		}
	132	+
	133	+	fn is_installed(ss: &str) -> Result<()> {
	134	+	let output = Command::new("which")
	135	+	.arg(ss)
	136	+	.output()
	137	+	.expect("Failed to execute command");
	138	+	if output.status.success() {
	139	+	Ok(())
	140	+	} else {
	141	+	let err = format!("{} not installed", ss);
	142	+	Err(err.into())
	143	+	}
	144	+	}

	@@ -0,0 +1,6 @@
1	+	#[derive(Debug)]
2	+	pub enum Error {
3	+	DmenuNotInstalled,
4	+	FzfNotInstalled,
5	+	}
6	+

	@@ -0,0 +1,79 @@
1	+	use crate::app::AppResult;
2	+	use crossterm::event::{self, Event as CrosstermEvent, KeyEvent, MouseEvent};
3	+	use std::sync::mpsc;
4	+	use std::thread;
5	+	use std::time::{Duration, Instant};
6	+
7	+	/// Terminal events.
8	+	#[derive(Clone, Copy, Debug)]
9	+	pub enum Event {
10	+	/// Terminal tick.
11	+	Tick,
12	+	/// Key press.
13	+	Key(KeyEvent),
14	+	/// Mouse click/scroll.
15	+	Mouse(MouseEvent),
16	+	/// Terminal resize.
17	+	Resize(u16, u16),
18	+	}
19	+
20	+	/// Terminal event handler.
21	+	#[allow(dead_code)]
22	+	#[derive(Debug)]
23	+	pub struct EventHandler {
24	+	/// Event sender channel.
25	+	sender: mpsc::Sender<Event>,
26	+	/// Event receiver channel.
27	+	receiver: mpsc::Receiver<Event>,
28	+	/// Event handler thread.
29	+	handler: thread::JoinHandle<()>,
30	+	}
31	+
32	+	impl EventHandler {
33	+	/// Constructs a new instance of [`EventHandler`].
34	+	pub fn new(tick_rate: u64) -> Self {
35	+	let tick_rate = Duration::from_millis(tick_rate);
36	+	let (sender, receiver) = mpsc::channel();
37	+	let handler = {
38	+	let sender = sender.clone();
39	+	thread::spawn(move \|\| {
40	+	let mut last_tick = Instant::now();
41	+	loop {
42	+	let timeout = tick_rate
43	+	.checked_sub(last_tick.elapsed())
44	+	.unwrap_or(tick_rate);
45	+
46	+	if event::poll(timeout).expect("failed to poll new events") {
47	+	match event::read().expect("unable to read event") {
48	+	CrosstermEvent::Key(e) => sender.send(Event::Key(e)),
49	+	CrosstermEvent::Mouse(e) => sender.send(Event::Mouse(e)),
50	+	CrosstermEvent::Resize(w, h) => sender.send(Event::Resize(w, h)),
51	+	CrosstermEvent::FocusGained => Ok(()),
52	+	CrosstermEvent::FocusLost => Ok(()),
53	+	CrosstermEvent::Paste(_) => unimplemented!(),
54	+	}
55	+	.expect("failed to send terminal event")
56	+	}
57	+
58	+	if last_tick.elapsed() >= tick_rate {
59	+	sender.send(Event::Tick).expect("failed to send tick event");
60	+	last_tick = Instant::now();
61	+	}
62	+	}
63	+	})
64	+	};
65	+	Self {
66	+	sender,
67	+	receiver,
68	+	handler,
69	+	}
70	+	}
71	+
72	+	/// Receive the next event from the handler thread.
73	+	///
74	+	/// This function will always block the current thread if
75	+	/// there is no data available and it's possible for more data to be sent.
76	+	pub fn next(&self) -> AppResult<Event> {
77	+	Ok(self.receiver.recv()?)
78	+	}
79	+	}

		@@ -10,3 +10,5 @@ mpd = "0.1.0"
10	10		clap = { version = "4.0.29", features = ["derive"] }
11	11		rust_fzf = "0.3.1"
12	12		simple-dmenu = "0.1.0"
	13	+	ratatui = "0.26.2"
	14	+	crossterm = "0.27.0"

	@@ -0,0 +1,47 @@
1	+	use crate::app::{App, AppResult};
2	+	use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
3	+
4	+	pub fn handle_key_events(key_event: KeyEvent, app: &mut App) -> AppResult<()> {
5	+	match key_event.code {
6	+	KeyCode::Char('q') \| KeyCode::Esc => app.quit(),
7	+	KeyCode::Char('c') \| KeyCode::Char('C') => {
8	+	if key_event.modifiers == KeyModifiers::CONTROL {
9	+	app.quit();
10	+	}
11	+	}
12	+
13	+	KeyCode::Char('j') => {
14	+	app.list.next();
15	+	}
16	+
17	+	KeyCode::Char('k') => {
18	+	app.list.prev();
19	+	}
20	+
21	+	KeyCode::Enter \| KeyCode::Char('l') => {
22	+	let song = app.conn.get_song_with_only_filename(app.conn.songs_filenames.get(app.list.index).unwrap());
23	+	app.conn.push(&song).unwrap();
24	+	app.update_queue();
25	+	}
26	+
27	+	// Playback controls
28	+	// Toggle Pause
29	+	KeyCode::Char('p') => {
30	+	app.conn.toggle_pause();
31	+	}
32	+
33	+	// Pause
34	+	KeyCode::Char('s') => {
35	+	app.conn.pause();
36	+	}
37	+
38	+	// Clearn Queue
39	+	KeyCode::Char('x') => {
40	+	app.conn.conn.clear()?;
41	+	app.update_queue();
42	+	}
43	+	_ => {}
44	+	}
45	+
46	+	Ok(())
47	+	}

	@@ -0,0 +1,23 @@
1	+	/// Command line interface (deprecated)
2	+	pub mod cli;
3	+
4	+	/// Handle mpd connection
5	+	pub mod connection;
6	+
7	+	/// Widget renderer
8	+	pub mod ui;
9	+
10	+	/// Terminal user Interface
11	+	pub mod tui;
12	+
13	+	/// Content list
14	+	pub mod list;
15	+
16	+	/// Event Handler
17	+	pub mod event;
18	+
19	+	/// KeyEvent Handler
20	+	pub mod handler;
21	+
22	+	/// Application
23	+	pub mod app;

	@@ -0,0 +1,24 @@
1	+	#[derive(Debug)]
2	+	pub struct ContentList {
3	+	pub index: usize
4	+	}
5	+
6	+	impl ContentList {
7	+	pub fn new() -> Self {
8	+	ContentList {
9	+	index: 0
10	+	}
11	+	}
12	+
13	+	// Go to next item in list
14	+	pub fn next(&mut self) {
15	+	self.index += 1;
16	+	}
17	+
18	+	/// Go to previous item in list
19	+	pub fn prev(&mut self) {
20	+	if self.index != 0 {
21	+	self.index -= 1;
22	+	}
23	+	}
24	+	}

		@@ -1,24 +1,63 @@
1		−	mod cli;
2		−	mod connection;
	1	+	#![allow(unused_imports)]
3	2		use clap::Parser;
4		−	use cli::Args;
5		−	use cli::Command;
6		−	use connection::Connection;
	3	+	use rmptui::app;
	4	+	use rmptui::app::App;
	5	+	use rmptui::app::AppResult;
	6	+	use rmptui::cli::Args;
	7	+	use rmptui::cli::Command;
	8	+	use rmptui::connection::Connection;
	9	+	use rmptui::event::Event;
	10	+	use rmptui::event::EventHandler;
	11	+	use rmptui::handler;
	12	+	use rmptui::tui;
	13	+	use std::io;
7	14
8		−	fn main() -> Result<(), Box<dyn std::error::Error>> {
9		−	let args = Args::parse();
10		−	let mut conn = Connection::new("127.0.0.1:6600")?;
	15	+	use crossterm::event::{self, KeyCode, KeyEvent, KeyEventKind};
	16	+	use ratatui::{
	17	+	prelude::*,
	18	+	symbols::border,
	19	+	widgets::{block::, },
	20	+	};
11	21
12		−	match args.command {
13		−	Command::Volume { vol } => {
14		−	conn.set_volume(vol);
	22	+	pub type Result<T> = core::result::Result<T, Error>;
	23	+	pub type Error = Box<dyn std::error::Error>;
	24	+
	25	+	fn main() -> AppResult<()> {
	26	+	// let args = Args::parse();
	27	+
	28	+	// if args.no_tui {
	29	+	// handle_tui()?;
	30	+	// } else {
	31	+	// match args.command {
	32	+	// Command::Volume { vol } => {
	33	+	// conn.set_volume(vol);
	34	+	// }
	35	+	// Command::Dmenu => conn.play_dmenu().unwrap(),
	36	+	// Command::Fzf => conn.play_fzf().unwrap(),
	37	+	// Command::Status => conn.status(),
	38	+	// Command::Pause => conn.pause(),
	39	+	// Command::Toggle => conn.toggle_pause(),
	40	+	// };
	41	+	// }
	42	+
	43	+	let backend = CrosstermBackend::new(io::stderr());
	44	+	let terminal = Terminal::new(backend)?;
	45	+	let mut app = App::new("127.0.0.1:6600");
	46	+	let events = EventHandler::new(250);
	47	+
	48	+	let mut tui = tui::Tui::new(terminal, events);
	49	+	tui.init()?;
	50	+
	51	+	while app.running {
	52	+	tui.draw(&mut app)?;
	53	+	match tui.events.next()? {
	54	+	Event::Tick => app.tick(),
	55	+	Event::Key(key_event) => handler::handle_key_events(key_event, &mut app)?,
	56	+	Event::Mouse(_) => {}
	57	+	Event::Resize(_, _) => {}
15	58		}
16		−	Command::Dmenu => conn.play_dmenu(),
17		−	Command::Fzf => conn.play_fzf(),
18		−	Command::Status => conn.status(),
19		−	Command::Pause => conn.pause(),
20		−	Command::Toggle => conn.toggle_pause(),
21	59		}
22	60
	61	+
23	62		Ok(())
24	63		}

	@@ -0,0 +1,66 @@
1	+	use crate::connection::Connection;
2	+	use crate::ui;
3	+	use crossterm::event::{DisableMouseCapture, EnableMouseCapture};
4	+	use crossterm::{
5	+	terminal::{self, *},
6	+	};
7	+	use ratatui::prelude::*;
8	+	use std::io::{self, stdout, Stdout};
9	+	use std::panic;
10	+
11	+	use crate::app::{App, AppResult};
12	+	use crate::event::EventHandler;
13	+
14	+	pub type CrosstermTerminal = ratatui::Terminal<ratatui::backend::CrosstermBackend<std::io::Stderr>>;
15	+
16	+	#[derive(Debug)]
17	+	pub struct Tui {
18	+	terminal: CrosstermTerminal,
19	+	pub events: EventHandler,
20	+	}
21	+
22	+	impl Tui {
23	+	pub fn new(terminal: CrosstermTerminal, events: EventHandler) -> Self {
24	+	Self { terminal, events }
25	+	}
26	+
27	+	pub fn init(&mut self) -> AppResult<()> {
28	+	terminal::enable_raw_mode()?;
29	+	crossterm::execute!(io::stdout(), EnterAlternateScreen, EnableMouseCapture)?;
30	+
31	+	let panic_hook = panic::take_hook();
32	+	panic::set_hook(Box::new(move \|panic\| {
33	+	Self::reset().expect("failed to reset the terminal");
34	+	panic_hook(panic);
35	+	}));
36	+	Ok(())
37	+	}
38	+
39	+	/// [`Draw`] the terminal interface by [`rendering`] the widgets.
40	+	///
41	+	/// [`Draw`]: ratatui::Terminal::draw
42	+	/// [`rendering`]: crate::ui::render
43	+	pub fn draw(&mut self, app: &mut App) -> AppResult<()> {
44	+	self.terminal.draw(\|frame\| ui::render(app, frame))?;
45	+	Ok(())
46	+	}
47	+
48	+	/// Resets the terminal interface.
49	+	///
50	+	/// This function is also used for the panic hook to revert
51	+	/// the terminal properties if unexpected errors occur.
52	+	fn reset() -> AppResult<()> {
53	+	terminal::disable_raw_mode()?;
54	+	crossterm::execute!(io::stderr(), LeaveAlternateScreen, DisableMouseCapture)?;
55	+	Ok(())
56	+	}
57	+
58	+	/// Exits the terminal interface.
59	+	///
60	+	/// It disables the raw mode and reverts back the terminal properties.
61	+	pub fn exit(&mut self) -> AppResult<()> {
62	+	Self::reset()?;
63	+	self.terminal.show_cursor()?;
64	+	Ok(())
65	+	}
66	+	}

	@@ -0,0 +1,37 @@
1	+	use crate::{app::App, connection::Connection};
2	+	use ratatui::{prelude::, widgets::};
3	+
4	+	/// Renders the user interface widgets
5	+	pub fn render(app: &mut App, frame: &mut Frame) {
6	+	// This is where you add new widgets.
7	+	// See the following resources:
8	+	// - https://docs.rs/ratatui/latest/ratatui/widgets/index.html
9	+	// - https://github.com/ratatui-org/ratatui/tree/master/examples
10	+
11	+	// List of songs
12	+	let mut state = ListState::default();
13	+	let size = Rect::new(100, 0, frame.size().width, frame.size().height - 3);
14	+	let list = List::new(app.conn.songs_filenames.clone())
15	+	.block(Block::default().title("Song List").borders(Borders::ALL))
16	+	.highlight_style(Style::new().add_modifier(Modifier::REVERSED))
17	+	.highlight_symbol(">>")
18	+	.repeat_highlight_symbol(true);
19	+
20	+	state.select(Some(app.list.index));
21	+	frame.render_stateful_widget(list, size, &mut state);
22	+
23	+	// Play Queue
24	+	let size = Rect::new(0, 0, 100, frame.size().height - 25);
25	+	let list = List::new(app.play_deque.clone())
26	+	.block(Block::default().title("Play Queue").borders(Borders::ALL))
27	+	.highlight_style(Style::new().add_modifier(Modifier::REVERSED))
28	+	.highlight_symbol(">>")
29	+	.repeat_highlight_symbol(true);
30	+	frame.render_widget(list, size);
31	+
32	+	// Status
33	+	let size = Rect::new(0, frame.size().height - 3, frame.size().width, 3);
34	+	let status = Paragraph::new(app.conn.conn.status().unwrap().volume.to_string())
35	+	.block(Block::default().title("Status").borders(Borders::ALL));
36	+	frame.render_widget(status, size);
37	+	}

		@@ -2,6 +2,24 @@
2	2		# It is not intended for manual editing.
3	3		version = 3
4	4
	5	+	[[package]]
	6	+	name = "ahash"
	7	+	version = "0.8.11"
	8	+	source = "registry+https://github.com/rust-lang/crates.io-index"
	9	+	checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
	10	+	dependencies = [
	11	+	"cfg-if",
	12	+	"once_cell",
	13	+	"version_check",
	14	+	"zerocopy",
	15	+	]
	16	+
	17	+	[[package]]
	18	+	name = "allocator-api2"
	19	+	version = "0.2.18"
	20	+	source = "registry+https://github.com/rust-lang/crates.io-index"
	21	+	checksum = "5c6cb57a04249c6480766f7f7cef5467412af1490f8d1e243141daddada3264f"
	22	+
5	23		[[package]]
6	24		name = "anstream"
7	25		version = "0.6.13"
		@@ -37,7 +55,7 @@ version = "1.0.2"
37	55		source = "registry+https://github.com/rust-lang/crates.io-index"
38	56		checksum = "e28923312444cdd728e4738b3f9c9cac739500909bb3d3c94b43551b16517648"
39	57		dependencies = [
40		−	"windows-sys",
	58	+	"windows-sys 0.52.0",
41	59		]
42	60
43	61		[[package]]
		@@ -47,15 +65,54 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
47	65		checksum = "1cd54b81ec8d6180e24654d0b371ad22fc3dd083b6ff8ba325b72e00c87660a7"
48	66		dependencies = [
49	67		"anstyle",
50		−	"windows-sys",
	68	+	"windows-sys 0.52.0",

rmptui/a0582ea

get basic tui working with Ratatui

rmptuia0582ea