pull/8/head
Takayuki Maeda 3 years ago
parent 1288cc9447
commit a101eeb702

1729
Cargo.lock generated

File diff suppressed because it is too large Load Diff

@ -5,3 +5,10 @@ authors = ["Takayuki Maeda <takoyaki0316@gmail.com>"]
edition = "2018"
[dependencies]
tui = { version = "0.14.0", features = ["crossterm"], default-features = false }
crossterm = "0.19"
anyhow = "1.0.38"
unicode-width = "0.1"
sqlx = { version = "0.4.1", features = ["mysql", "runtime-tokio-rustls"] }
tokio = { version = "0.2", features = ["full"] }
futures = "0.3.5"

@ -0,0 +1,31 @@
pub enum InputMode {
Normal,
Editing,
}
pub struct App {
/// Current value of the input box
pub input: String,
/// Current input mode
pub input_mode: InputMode,
/// History of recorded messages
pub messages: Vec<Vec<String>>,
pub tables: Vec<String>,
}
impl Default for App {
fn default() -> App {
App {
input: String::new(),
input_mode: InputMode::Normal,
messages: Vec::new(),
tables: Vec::new(),
}
}
}
impl App {
pub fn new(title: &str, enhanced_graphics: bool) -> App {
Self::default()
}
}

@ -1,3 +1,182 @@
fn main() {
println!("Hello, world!");
mod app;
mod ui;
use crate::app::App;
use crate::app::InputMode;
use crossterm::{
event::{self, DisableMouseCapture, EnableMouseCapture, Event as CEvent, KeyCode},
execute,
terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
};
use std::sync::{
atomic::{AtomicBool, Ordering},
Arc,
};
use std::{
error::Error,
io::stdout,
sync::mpsc,
thread,
time::{Duration, Instant},
};
use tui::{backend::CrosstermBackend, widgets::TableState, Terminal};
enum Event<I> {
Input(I),
Tick,
}
pub struct StatefulTable<'a> {
state: TableState,
items: Vec<Vec<&'a str>>,
}
impl<'a> StatefulTable<'a> {
fn new() -> StatefulTable<'a> {
StatefulTable {
state: TableState::default(),
items: vec![
vec!["Row11", "Row12", "Row13", "Row14", "Row15", "Row16"],
vec!["Row11", "Row12", "Row13", "Row13", "Row13", "Row13"],
],
}
}
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));
}
}
/// Crossterm demo
#[derive(Debug)]
struct Cli {
/// time in ms between two ticks.
tick_rate: u64,
/// whether unicode symbols are used to improve the overall look of the app
enhanced_graphics: bool,
}
#[tokio::main]
async fn main() -> anyhow::Result<()> {
let cli: Cli = Cli {
tick_rate: 250,
enhanced_graphics: true,
};
enable_raw_mode()?;
let mut stdout = stdout();
execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
let backend = CrosstermBackend::new(stdout);
let mut terminal = Terminal::new(backend)?;
// Setup input handling
let (tx, rx) = mpsc::channel();
let tick_rate = Duration::from_millis(cli.tick_rate);
thread::spawn(move || {
let mut last_tick = Instant::now();
loop {
// poll for tick rate duration, if no events, sent tick event.
let timeout = tick_rate
.checked_sub(last_tick.elapsed())
.unwrap_or_else(|| Duration::from_secs(0));
if event::poll(timeout).unwrap() {
if let CEvent::Key(key) = event::read().unwrap() {
tx.send(Event::Input(key)).unwrap();
}
}
if last_tick.elapsed() >= tick_rate {
tx.send(Event::Tick).unwrap();
last_tick = Instant::now();
}
}
});
use sqlx::mysql::{MySqlPool, MySqlRow};
use sqlx::Row as _;
let mut app = App::new("Crossterm Demo", cli.enhanced_graphics);
let pool = MySqlPool::connect("mysql://root:@localhost:3306/hoge").await?;
let mut rows = sqlx::query("SELECT * FROM user").fetch(&pool);
let mut tables = sqlx::query("show tables")
.fetch_all(&pool)
.await?
.iter()
.map(|table| table.get(0))
.collect::<Vec<String>>();
app.tables = tables;
terminal.clear()?;
let mut table = StatefulTable::new();
loop {
terminal.draw(|f| ui::draw(f, &mut app, &mut table).unwrap())?;
match rx.recv()? {
Event::Input(event) => match app.input_mode {
InputMode::Normal => match event.code {
KeyCode::Char('e') => {
app.input_mode = InputMode::Editing;
}
KeyCode::Char('q') => {
disable_raw_mode()?;
execute!(
terminal.backend_mut(),
LeaveAlternateScreen,
DisableMouseCapture
)?;
terminal.show_cursor()?;
break;
}
KeyCode::Up => table.previous(),
KeyCode::Down => table.next(),
_ => {}
},
InputMode::Editing => match event.code {
KeyCode::Enter => {
app.messages.push(vec![app.input.drain(..).collect()]);
}
KeyCode::Char(c) => {
app.input.push(c);
}
KeyCode::Backspace => {
app.input.pop();
}
KeyCode::Esc => {
app.input_mode = InputMode::Normal;
}
_ => {}
},
},
Event::Tick => (),
}
}
Ok(())
}

@ -0,0 +1,141 @@
use crate::app::InputMode;
use crate::App;
use crate::StatefulTable;
use tui::{
backend::Backend,
layout::{Constraint, Direction, Layout, Rect},
style::{Color, Modifier, Style},
symbols,
text::{Span, Spans, Text},
widgets::canvas::{Canvas, Line, Map, MapResolution, Rectangle},
widgets::{
Axis, BarChart, Block, Borders, Cell, Chart, Dataset, Gauge, LineGauge, List, ListItem,
Paragraph, Row, Sparkline, Table, Tabs, Wrap,
},
Frame,
};
use unicode_width::UnicodeWidthStr;
pub fn draw<B: Backend>(
f: &mut Frame<'_, B>,
app: &mut App,
table: &mut StatefulTable<'_>,
) -> anyhow::Result<()> {
let chunks = Layout::default()
.direction(Direction::Vertical)
.margin(2)
.constraints([Constraint::Percentage(15), Constraint::Percentage(85)])
.direction(Direction::Horizontal)
.split(f.size());
let tables: Vec<ListItem> = app
.tables
.iter()
.map(|i| ListItem::new(vec![Spans::from(Span::raw(i))]))
.collect();
let tasks = List::new(tables)
.block(Block::default().borders(Borders::ALL).title("Tables"))
.highlight_style(Style::default().add_modifier(Modifier::BOLD))
.highlight_symbol("> ");
f.render_widget(tasks, chunks[0]);
let chunks = Layout::default()
.direction(Direction::Vertical)
.constraints(
[
Constraint::Length(1),
Constraint::Length(3),
Constraint::Min(1),
]
.as_ref(),
)
.split(chunks[1]);
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("e", Style::default().add_modifier(Modifier::BOLD)),
Span::raw(" to start editing."),
],
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 record the message"),
],
Style::default(),
),
};
let mut text = Text::from(Spans::from(msg));
text.patch_style(style);
let help_message = Paragraph::new(text);
f.render_widget(help_message, chunks[0]);
let input = Paragraph::new(app.input.as_ref())
.style(match app.input_mode {
InputMode::Normal => Style::default(),
InputMode::Editing => Style::default().fg(Color::Yellow),
})
.block(Block::default().borders(Borders::ALL).title("Input"));
f.render_widget(input, chunks[1]);
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[1].x + app.input.width() as u16 + 1,
// Move one line down, from the border to the input line
chunks[1].y + 1,
)
}
}
let selected_style = Style::default().add_modifier(Modifier::REVERSED);
let normal_style = Style::default().bg(Color::Blue);
let header_cells = [
"Header1", "Header2", "Header3", "Header4", "Header5", "Header6",
]
.iter()
.map(|h| Cell::from(*h).style(Style::default().fg(Color::Red)));
let header = Row::new(header_cells)
.style(normal_style)
.height(1)
.bottom_margin(1);
let rows = app.messages.iter().map(|item| {
let height = item
.iter()
.map(|content| content.chars().filter(|c| *c == '\n').count())
.max()
.unwrap_or(0)
+ 1;
let cells = item.iter().map(|c| Cell::from(c.to_string()));
Row::new(cells).height(height as u16).bottom_margin(1)
});
let t = Table::new(rows)
.header(header)
.block(Block::default().borders(Borders::ALL).title("Table"))
.highlight_style(selected_style)
.highlight_symbol(">> ")
.widths(&[
Constraint::Percentage(10),
Constraint::Percentage(10),
Constraint::Percentage(10),
Constraint::Percentage(10),
Constraint::Percentage(10),
Constraint::Percentage(10),
]);
f.render_stateful_widget(t, chunks[2], &mut table.state);
Ok(())
}
Loading…
Cancel
Save