Archives
/
tui-rs
mirror of https://github.com/fdehau/tui-rs
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

chore: remove unecessary dependencies

Browse Source 
* Remove log, stderrlog, structopt
* Add argh
pull/244/head
Florian Dehau 4 years ago
parent 278c153d31
commit 3f62ce9c19
21 changed files with 180 additions and 227 deletions
Show Stats Download Patch File Download Diff File

5
Cargo.toml
Unescape Escape View File

@ -22,7 +22,6 @@ curses = ["easycurses", "pancurses"]
bitflags = "1.0"
cassowary = "0.3"
itertools = "0.8"
log = "0.4"
either = "1.5"
unicode-segmentation = "1.2"
unicode-width = "0.1"
@ -33,10 +32,8 @@ easycurses = { version = "0.12.2", optional = true }
pancurses = { version = "0.16.1", optional = true, features = ["win32a"] }
[dev-dependencies]
stderrlog = "0.4"
rand = "0.7"
failure = "0.1"
structopt = "0.3"
argh = "0.1"
[[example]]
name = "canvas"

23
examples/barchart.rs
Unescape Escape View File

@ -1,19 +1,16 @@
#[allow(dead_code)]
mod util;
use std::io;
use termion::event::Key;
use termion::input::MouseTerminal;
use termion::raw::IntoRawMode;
use termion::screen::AlternateScreen;
use tui::backend::TermionBackend;
use tui::layout::{Constraint, Direction, Layout};
use tui::style::{Color, Modifier, Style};
use tui::widgets::{BarChart, Block, Borders};
use tui::Terminal;
use crate::util::event::{Event, Events};
use std::{error::Error, io};
use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
use tui::{
backend::TermionBackend,
layout::{Constraint, Direction, Layout},
style::{Color, Modifier, Style},
widgets::{BarChart, Block, Borders},
Terminal,
};
struct App<'a> {
data: Vec<(&'a str, u64)>,
@ -57,7 +54,7 @@ impl<'a> App<'a> {
}
}
fn main() -> Result<(), failure::Error> {
fn main() -> Result<(), Box<dyn Error>> {
// Terminal initialization
let stdout = io::stdout().into_raw_mode()?;
let stdout = MouseTerminal::from(stdout);

22
examples/block.rs
Unescape Escape View File

@ -1,20 +1,18 @@
#[allow(dead_code)]
mod util;
use std::io;
use termion::event::Key;
use termion::input::MouseTerminal;
use termion::raw::IntoRawMode;
use termion::screen::AlternateScreen;
use tui::backend::TermionBackend;
use tui::layout::{Constraint, Direction, Layout};
use tui::style::{Color, Modifier, Style};
use tui::widgets::{Block, BorderType, Borders};
use tui::Terminal;
use crate::util::event::{Event, Events};
use std::{error::Error, io};
use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
use tui::{
backend::TermionBackend,
layout::{Constraint, Direction, Layout},
style::{Color, Modifier, Style},
widgets::{Block, BorderType, Borders},
Terminal,
};
fn main() -> Result<(), failure::Error> {
fn main() -> Result<(), Box<dyn Error>> {
// Terminal initialization
let stdout = io::stdout().into_raw_mode()?;
let stdout = MouseTerminal::from(stdout);

28
examples/canvas.rs
Unescape Escape View File

@ -1,21 +1,19 @@
#[allow(dead_code)]
mod util;
use std::io;
use std::time::Duration;
use termion::event::Key;
use termion::input::MouseTerminal;
use termion::raw::IntoRawMode;
use termion::screen::AlternateScreen;
use tui::backend::TermionBackend;
use tui::layout::{Constraint, Direction, Layout, Rect};
use tui::style::Color;
use tui::widgets::canvas::{Canvas, Map, MapResolution, Rectangle};
use tui::widgets::{Block, Borders};
use tui::Terminal;
use crate::util::event::{Config, Event, Events};
use std::{error::Error, io, time::Duration};
use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
use tui::{
backend::TermionBackend,
layout::{Constraint, Direction, Layout, Rect},
style::Color,
widgets::{
canvas::{Canvas, Map, MapResolution, Rectangle},
Block, Borders,
},
Terminal,
};
struct App {
x: f64,
@ -74,7 +72,7 @@ impl App {
}
}
fn main() -> Result<(), failure::Error> {
fn main() -> Result<(), Box<dyn Error>> {
// Terminal initialization
let stdout = io::stdout().into_raw_mode()?;
let stdout = MouseTerminal::from(stdout);

4
examples/chart.rs
Unescape Escape View File

@ -5,7 +5,7 @@ use crate::util::{
event::{Event, Events},
SinSignal,
};
use std::io;
use std::{error::Error, io};
use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
use tui::{
backend::TermionBackend,
@ -63,7 +63,7 @@ impl App {
}
}
fn main() -> Result<(), failure::Error> {
fn main() -> Result<(), Box<dyn Error>> {
// Terminal initialization
let stdout = io::stdout().into_raw_mode()?;
let stdout = MouseTerminal::from(stdout);

16
examples/crossterm_demo.rs
Unescape Escape View File

@ -4,18 +4,19 @@ mod demo;
mod util;
use crate::demo::{ui, App};
use argh::FromArgs;
use crossterm::{
event::{self, Event as CEvent, KeyCode},
execute,
terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
};
use std::{
error::Error,
io::{stdout, Write},
sync::mpsc,
thread,
time::Duration,
};
use structopt::StructOpt;
use tui::{backend::CrosstermBackend, Terminal};
enum Event<I> {
@ -23,17 +24,16 @@ enum Event<I> {
Tick,
}
#[derive(Debug, StructOpt)]
/// Crossterm demo
#[derive(Debug, FromArgs)]
struct Cli {
#[structopt(long = "tick-rate", default_value = "250")]
/// time in ms between two ticks.
#[argh(option, default = "250")]
tick_rate: u64,
#[structopt(long = "log")]
log: bool,
}
fn main() -> Result<(), failure::Error> {
let cli = Cli::from_args();
stderrlog::new().quiet(!cli.log).verbosity(4).init()?;
fn main() -> Result<(), Box<dyn Error>> {
let cli: Cli = argh::from_env();
enable_raw_mode()?;

29
examples/curses_demo.rs
Unescape Escape View File

@ -2,27 +2,26 @@ mod demo;
#[allow(dead_code)]
mod util;
use std::io;
use std::time::{Duration, Instant};
use easycurses;
use structopt::StructOpt;
use tui::backend::CursesBackend;
use tui::Terminal;
use crate::demo::{ui, App};
use argh::FromArgs;
use easycurses;
use std::{
error::Error,
io,
time::{Duration, Instant},
};
use tui::{backend::CursesBackend, Terminal};
#[derive(Debug, StructOpt)]
/// Curses demo
#[derive(Debug, FromArgs)]
struct Cli {
#[structopt(long = "tick-rate", default_value = "250")]
/// time in ms between two ticks.
#[argh(option, default = "250")]
tick_rate: u64,
#[structopt(long = "log")]
log: bool,
}
fn main() -> Result<(), failure::Error> {
let cli = Cli::from_args();
stderrlog::new().quiet(!cli.log).verbosity(4).init()?;
fn main() -> Result<(), Box<dyn Error>> {
let cli: Cli = argh::from_env();
let mut backend = CursesBackend::new().ok_or(io::Error::new(io::ErrorKind::Other, ""))?;
let curses = backend.get_curses_mut();

20
examples/custom_widget.rs
Unescape Escape View File

@ -1,20 +1,12 @@
#[allow(dead_code)]
mod util;
use std::io;
use termion::event::Key;
use termion::input::MouseTerminal;
use termion::raw::IntoRawMode;
use termion::screen::AlternateScreen;
use tui::backend::TermionBackend;
use tui::buffer::Buffer;
use tui::layout::Rect;
use tui::style::Style;
use tui::widgets::Widget;
use tui::Terminal;
use crate::util::event::{Event, Events};
use std::{error::Error, io};
use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
use tui::{
backend::TermionBackend, buffer::Buffer, layout::Rect, style::Style, widgets::Widget, Terminal,
};
struct Label<'a> {
text: &'a str,
@ -39,7 +31,7 @@ impl<'a> Label<'a> {
}
}
fn main() -> Result<(), failure::Error> {
fn main() -> Result<(), Box<dyn Error>> {
// Terminal initialization
let stdout = io::stdout().into_raw_mode()?;
let stdout = MouseTerminal::from(stdout);

23
examples/gauge.rs
Unescape Escape View File

@ -1,19 +1,16 @@
#[allow(dead_code)]
mod util;
use std::io;
use termion::event::Key;
use termion::input::MouseTerminal;
use termion::raw::IntoRawMode;
use termion::screen::AlternateScreen;
use tui::backend::TermionBackend;
use tui::layout::{Constraint, Direction, Layout};
use tui::style::{Color, Modifier, Style};
use tui::widgets::{Block, Borders, Gauge};
use tui::Terminal;
use crate::util::event::{Event, Events};
use std::{error::Error, io};
use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
use tui::{
backend::TermionBackend,
layout::{Constraint, Direction, Layout},
style::{Color, Modifier, Style},
widgets::{Block, Borders, Gauge},
Terminal,
};
struct App {
progress1: u16,
@ -52,7 +49,7 @@ impl App {
}
}
fn main() -> Result<(), failure::Error> {
fn main() -> Result<(), Box<dyn Error>> {
// Terminal initialization
let stdout = io::stdout().into_raw_mode()?;
let stdout = MouseTerminal::from(stdout);

23
examples/layout.rs
Unescape Escape View File

@ -1,20 +1,17 @@
#[allow(dead_code)]
mod util;
use std::io;
use termion::event::Key;
use termion::input::MouseTerminal;
use termion::raw::IntoRawMode;
use termion::screen::AlternateScreen;
use tui::backend::TermionBackend;
use tui::layout::{Constraint, Direction, Layout};
use tui::widgets::{Block, Borders};
use tui::Terminal;
use crate::util::event::{Event, Events};
fn main() -> Result<(), failure::Error> {
use std::{error::Error, io};
use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
use tui::{
backend::TermionBackend,
layout::{Constraint, Direction, Layout},
widgets::{Block, Borders},
Terminal,
};
fn main() -> Result<(), Box<dyn Error>> {
// Terminal initialization
let stdout = io::stdout().into_raw_mode()?;
let stdout = MouseTerminal::from(stdout);

23
examples/list.rs
Unescape Escape View File

@ -1,22 +1,19 @@
#[allow(dead_code)]
mod util;
use std::io;
use termion::event::Key;
use termion::input::MouseTerminal;
use termion::raw::IntoRawMode;
use termion::screen::AlternateScreen;
use tui::backend::TermionBackend;
use tui::layout::{Constraint, Corner, Direction, Layout};
use tui::style::{Color, Modifier, Style};
use tui::widgets::{Block, Borders, List, Text};
use tui::Terminal;
use crate::util::{
event::{Event, Events},
StatefulList,
};
use std::{error::Error, io};
use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
use tui::{
backend::TermionBackend,
layout::{Constraint, Corner, Direction, Layout},
style::{Color, Modifier, Style},
widgets::{Block, Borders, List, Text},
Terminal,
};
struct App<'a> {
items: StatefulList<&'a str>,
@ -76,7 +73,7 @@ impl<'a> App<'a> {
}
}
fn main() -> Result<(), failure::Error> {
fn main() -> Result<(), Box<dyn Error>> {
// Terminal initialization
let stdout = io::stdout().into_raw_mode()?;
let stdout = MouseTerminal::from(stdout);

23
examples/paragraph.rs
Unescape Escape View File

@ -1,21 +1,18 @@
#[allow(dead_code)]
mod util;
use std::io;
use termion::event::Key;
use termion::input::MouseTerminal;
use termion::raw::IntoRawMode;
use termion::screen::AlternateScreen;
use tui::backend::TermionBackend;
use tui::layout::{Alignment, Constraint, Direction, Layout};
use tui::style::{Color, Modifier, Style};
use tui::widgets::{Block, Borders, Paragraph, Text};
use tui::Terminal;
use crate::util::event::{Event, Events};
use std::{error::Error, io};
use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
use tui::{
backend::TermionBackend,
layout::{Alignment, Constraint, Direction, Layout},
style::{Color, Modifier, Style},
widgets::{Block, Borders, Paragraph, Text},
Terminal,
};
fn main() -> Result<(), failure::Error> {
fn main() -> Result<(), Box<dyn Error>> {
// Terminal initialization
let stdout = io::stdout().into_raw_mode()?;
let stdout = MouseTerminal::from(stdout);

27
examples/rustbox_demo.rs
Unescape Escape View File

@ -2,26 +2,25 @@ mod demo;
#[allow(dead_code)]
mod util;
use std::time::{Duration, Instant};
use rustbox::keyboard::Key;
use structopt::StructOpt;
use tui::backend::RustboxBackend;
use tui::Terminal;
use crate::demo::{ui, App};
use argh::FromArgs;
use rustbox::keyboard::Key;
use std::{
error::Error,
time::{Duration, Instant},
};
use tui::{backend::RustboxBackend, Terminal};
#[derive(Debug, StructOpt)]
/// Rustbox demo
#[derive(Debug, FromArgs)]
struct Cli {
#[structopt(long = "tick-rate", default_value = "250")]
/// time in ms between two ticks.
#[argh(option, default = "250")]
tick_rate: u64,
#[structopt(long = "log")]
log: bool,
}
fn main() -> Result<(), failure::Error> {
let cli = Cli::from_args();
stderrlog::new().quiet(!cli.log).verbosity(4).init()?;
fn main() -> Result<(), Box<dyn Error>> {
let cli: Cli = argh::from_env();
let backend = RustboxBackend::new()?;
let mut terminal = Terminal::new(backend)?;

29
examples/sparkline.rs
Unescape Escape View File

@ -1,20 +1,19 @@
#[allow(dead_code)]
mod util;
use std::io;
use termion::event::Key;
use termion::input::MouseTerminal;
use termion::raw::IntoRawMode;
use termion::screen::AlternateScreen;
use tui::backend::TermionBackend;
use tui::layout::{Constraint, Direction, Layout};
use tui::style::{Color, Style};
use tui::widgets::{Block, Borders, Sparkline};
use tui::Terminal;
use crate::util::event::{Event, Events};
use crate::util::RandomSignal;
use crate::util::{
event::{Event, Events},
RandomSignal,
};
use std::{error::Error, io};
use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
use tui::{
backend::TermionBackend,
layout::{Constraint, Direction, Layout},
style::{Color, Style},
widgets::{Block, Borders, Sparkline},
Terminal,
};
struct App {
signal: RandomSignal,
@ -50,7 +49,7 @@ impl App {
}
}
fn main() -> Result<(), failure::Error> {
fn main() -> Result<(), Box<dyn Error>> {
// Terminal initialization
let stdout = io::stdout().into_raw_mode()?;
let stdout = MouseTerminal::from(stdout);

4
examples/table.rs
Unescape Escape View File

@ -2,7 +2,7 @@
mod util;
use crate::util::event::{Event, Events};
use std::io;
use std::{error::Error, io};
use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
use tui::{
backend::TermionBackend,
@ -73,7 +73,7 @@ impl<'a> StatefulTable<'a> {
}
}
fn main() -> Result<(), failure::Error> {
fn main() -> Result<(), Box<dyn Error>> {
// Terminal initialization
let stdout = io::stdout().into_raw_mode()?;
let stdout = MouseTerminal::from(stdout);

29
examples/tabs.rs
Unescape Escape View File

@ -1,26 +1,25 @@
#[allow(dead_code)]
mod util;
use std::io;
use termion::event::Key;
use termion::input::MouseTerminal;
use termion::raw::IntoRawMode;
use termion::screen::AlternateScreen;
use tui::backend::TermionBackend;
use tui::layout::{Constraint, Direction, Layout};
use tui::style::{Color, Style};
use tui::widgets::{Block, Borders, Tabs};
use tui::Terminal;
use crate::util::event::{Event, Events};
use crate::util::TabsState;
use crate::util::{
event::{Event, Events},
TabsState,
};
use std::{error::Error, io};
use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
use tui::{
backend::TermionBackend,
layout::{Constraint, Direction, Layout},
style::{Color, Style},
widgets::{Block, Borders, Tabs},
Terminal,
};
struct App<'a> {
tabs: TabsState<'a>,
}
fn main() -> Result<(), failure::Error> {
fn main() -> Result<(), Box<dyn Error>> {
// Terminal initialization
let stdout = io::stdout().into_raw_mode()?;
let stdout = MouseTerminal::from(stdout);

28
examples/termion_demo.rs
Unescape Escape View File

@ -2,33 +2,25 @@ mod demo;
#[allow(dead_code)]
mod util;
use std::io;
use std::time::Duration;
use structopt::StructOpt;
use termion::event::Key;
use termion::input::MouseTerminal;
use termion::raw::IntoRawMode;
use termion::screen::AlternateScreen;
use tui::backend::TermionBackend;
use tui::Terminal;
use crate::{
demo::{ui, App},
util::event::{Config, Event, Events},
};
use argh::FromArgs;
use std::{error::Error, io, time::Duration};
use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
use tui::{backend::TermionBackend, Terminal};
#[derive(Debug, StructOpt)]
/// Termion demo
#[derive(Debug, FromArgs)]
struct Cli {
#[structopt(long = "tick-rate", default_value = "250")]
/// time in ms between two ticks.
#[argh(option, default = "250")]
tick_rate: u64,
#[structopt(long = "log")]
log: bool,
}
fn main() -> Result<(), failure::Error> {
let cli = Cli::from_args();
stderrlog::new().quiet(!cli.log).verbosity(4).init()?;
fn main() -> Result<(), Box<dyn Error>> {
let cli: Cli = argh::from_env();
let events = Events::with_config(Config {
tick_rate: Duration::from_millis(cli.tick_rate),

31
examples/user_input.rs
Unescape Escape View File

@ -13,21 +13,22 @@
#[allow(dead_code)]
mod util;
use std::io::{self, Write};
use termion::cursor::Goto;
use termion::event::Key;
use termion::input::MouseTerminal;
use termion::raw::IntoRawMode;
use termion::screen::AlternateScreen;
use tui::backend::TermionBackend;
use tui::layout::{Constraint, Direction, Layout};
use tui::style::{Color, Style};
use tui::widgets::{Block, Borders, List, Paragraph, Text};
use tui::Terminal;
use unicode_width::UnicodeWidthStr;
use crate::util::event::{Event, Events};
use std::{
error::Error,
io::{self, Write},
};
use termion::{
cursor::Goto, event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen,
};
use tui::{
backend::TermionBackend,
layout::{Constraint, Direction, Layout},
style::{Color, Style},
widgets::{Block, Borders, List, Paragraph, Text},
Terminal,
};
use unicode_width::UnicodeWidthStr;
enum InputMode {
Normal,
@ -54,7 +55,7 @@ impl Default for App {
}
}
fn main() -> Result<(), failure::Error> {
fn main() -> Result<(), Box<dyn Error>> {
// Terminal initialization
let stdout = io::stdout().into_raw_mode()?;
let stdout = MouseTerminal::from(stdout);

15
src/backend/rustbox.rs
Unescape Escape View File

@ -1,11 +1,11 @@
use log::debug;
use crate::{
backend::Backend,
buffer::Cell,
layout::Rect,
style::{Color, Modifier},
};
use std::io;
use super::Backend;
use crate::buffer::Cell;
use crate::layout::Rect;
use crate::style::{Color, Modifier};
pub struct RustboxBackend {
rustbox: rustbox::RustBox,
}
@ -30,9 +30,7 @@ impl Backend for RustboxBackend {
where
I: Iterator<Item = (u16, u16, &'a Cell)>,
{
let mut inst = 0;
for (x, y, cell) in content {
inst += 1;
self.rustbox.print(
x as usize,
y as usize,
@ -42,7 +40,6 @@ impl Backend for RustboxBackend {
&cell.symbol,
);
}
debug!("{} instructions outputed", inst);
Ok(())
}
fn hide_cursor(&mut self) -> Result<(), io::Error> {

2
src/backend/termion.rs
Unescape Escape View File

@ -1,4 +1,3 @@
use log::debug;
use std::fmt;
use std::io;
use std::io::Write;
@ -115,7 +114,6 @@ where
string.push_str(&cell.symbol);
inst += 1;
}
debug!("{} instructions outputed.", inst);
write!(
self.stdout,
"{}{}{}{}",

3
src/terminal.rs
Unescape Escape View File

@ -1,4 +1,3 @@
use log::error;
use std::io;
use crate::backend::Backend;
@ -65,7 +64,7 @@ where
// Attempt to restore the cursor state
if self.hidden_cursor {
if let Err(err) = self.show_cursor() {
error!("Failed to show the cursor: {}", err);
eprintln!("Failed to show the cursor: {}", err);
}
}
}

Write Preview
Loading…
Cancel
Save