Rustのターミナル操作crateいろいろ

use ncurses::*;

const MESSAGE: &str = "Merry Christmas !!";

fn main() {
    let window = initscr();
    start_color();
    use_default_colors();
    init_pair(1, COLOR_BLUE, -1);
    addstr("Hello world !!");
    refresh();
    keypad(window, true);
    noecho();
    curs_set(CURSOR_VISIBILITY::CURSOR_INVISIBLE);

    loop {
        match getch() {
             109 => {
                let y = getmaxy(window) / 2;
                let x = getmaxx(window) / 2 - (MESSAGE.len() / 2) as i32;
                clear();
                color_set(1);
                mvaddstr(y, x, MESSAGE);
            }
            KEY_DC => break,
            _ => (),
        }
    }
    endwin();
}

use pancurses::*;

const MESSAGE: &str = "Merry Christmas !!";

fn main() {
    let window = initscr();
    start_color();
    use_default_colors();
    init_pair(1, COLOR_BLUE, -1);
    window.printw("Hello world !!");
    window.refresh();
    window.keypad(true);
    noecho();
    curs_set(0);

    loop {
        match window.getch() {
            Some(Input::Character('m')) => {
                let y = window.get_max_y() / 2;
                let x = window.get_max_x() / 2 - (MESSAGE.len() / 2) as i32;
                window.clear();
                window.color_set(1);
                window.mvaddstr(y, x, MESSAGE);
            }
            Some(Input::KeyDC) => break,
            _ => (),
        }
    }
    endwin();
}

use rustbox::*;

const MESSAGE: &str = "Merry Christmas !!";

fn main() {
    let rustbox = RustBox::init(Default::default()).unwrap();
    rustbox.clear();
    rustbox.print(0, 0, rustbox::RB_NORMAL, Color::White, Color::Default,  "Hello world !!");
    rustbox.present();

    loop {
        match rustbox.poll_event(false) {
            Ok(rustbox::Event::KeyEvent(key)) => {
                match key {
                    Key::Char('m') => {
                        let x = rustbox.width() / 2 - (MESSAGE.len() / 2);
                        let y = rustbox.height() / 2;
                        rustbox.clear();
                        rustbox.print(x, y, rustbox::RB_BOLD, Color::Blue, Color::Default, MESSAGE);
                        rustbox.present();
                    },
                    Key::Ctrl('c') => break,
                    _ => {},
                }
            },
            _ => {},
        }
    }
}

use crossterm::*;
use std::io::{stdout, Write};
use crossterm::screen::RawScreen;

const MESSAGE: &str = "Merry Christmas !!";

fn main() {
    let _screen = RawScreen::into_raw_mode().unwrap();
    let input = input::input();
    let mut sync_stdin = input.read_sync();

    execute!(
        stdout(),
        cursor::Hide,
        terminal::Clear(terminal::ClearType::All)
    ).unwrap();

    execute!(
        stdout(),
        style::SetForegroundColor(style::Color::White),
        cursor::MoveTo(0, 0),
        Output("Hello world !!"),
        style::ResetColor
    ).unwrap();

    let (width, height) = terminal::size().unwrap();
    let x = width / 2 - (MESSAGE.len() / 2) as u16;
    let y = height / 2;

    loop {
        let event = sync_stdin.next();
        match event {
            Some(input::InputEvent::Keyboard(k)) => {
                match k {
                    input::KeyEvent::Char('m') => {
                        let styled = style::style("Merry Christmas !!")
                            .with(style::Color::Blue)
                            .attribute(style::Attribute::Bold);
                        execute!(
                                stdout(),
                                terminal::Clear(terminal::ClearType::All),
                                cursor::MoveTo(x, y),
                                style::PrintStyledContent(styled)
                            ).unwrap();
                    },
                    input::KeyEvent::Ctrl('c') => break,
                    _ => {},
                }
            },
            _ => {},
        }
    }

    execute!(
        stdout(),
        cursor::Show
    ).unwrap();
}

use termion::*;
use std::io::{Write, stdout, stdin};
use termion::input::TermRead;
use termion::raw::IntoRawMode;

const MESSAGE: &str = "Merry Christmas !!";

fn main() {
    let stdin = stdin();
    let mut stdout = stdout().into_raw_mode().unwrap();
    write!(stdout, "{}{}", clear::All, cursor::Hide).unwrap();
    write!(stdout, "{}Hello world !!", cursor::Goto(1, 1)).unwrap();
    stdout.flush().unwrap();

    for c in stdin.keys() {
        match c {
            Ok(event::Key::Char('m')) => {
                if let Ok((width, height)) = terminal_size() {
                    let x = width / 2 - (MESSAGE.len() / 2) as u16;
                    let y = height / 2;
                    write!(stdout, "{}{}{}{}{}{}",
                           clear::All,
                           cursor::Goto(x, y),
                           color::Fg(color::Blue),
                           style::Bold,
                           MESSAGE,
                           style::Reset,
                    ).unwrap();
                    stdout.flush().unwrap();
                }
            },
            Ok(event::Key::Ctrl('c')) => break,
            _ => {},
        }
    }

    write!(stdout, "{}", termion::cursor::Show).unwrap();
}

use cursive::*;

const MESSAGE: &str = "Merry Christmas !!";

enum State {
    HelloWorld,
    MerryChristmas,
}

struct StateContainer {
    state: State,
}

impl StateContainer {
    fn new() -> StateContainer{
        StateContainer { state: State::HelloWorld }
    }
}

fn main() {
    let mut siv = Cursive::default();
    let mut theme = theme::Theme::default();
    theme
        .palette
        .set_color("view", theme::Color::TerminalDefault);
    theme
        .palette
        .set_color("foreground", theme::Color::from_256colors(15));
    theme
        .palette
        .set_color("background", theme::Color::TerminalDefault);
    siv.set_theme(theme);

    let mut state = StateContainer::new();
    let mut canvas = views::Canvas::new(state);
   canvas.set_required_size(|_, constraint| {constraint});
    canvas.set_on_event(|state, event| {
        if event == event::Event::Char('m') {
            state.state = State::MerryChristmas;
        }
        event::EventResult::Ignored
    });
    canvas.set_draw(|state, printer| {
        match state.state {
            State::HelloWorld => {
                printer.print((0, 0), "Hello world !!");
            }
            State::MerryChristmas => {
                let x = printer.size.x / 2 - (MESSAGE.len() / 2);
                let y = printer.size.y / 2;
                let mut style = theme::Style::default();
                style.effects.insert(theme::Effect::Bold);
                style.color = Some(theme::ColorStyle::from(theme::Color::from_256colors(12)));
                printer.with_style(style, |p| {
                    p.print((x, y), MESSAGE);
                });
            }
        };
    });
    siv.add_fullscreen_layer(canvas);
    siv.run();
} 

use std::io;
use termion;
use termion::input::TermRead;
use termion::raw::IntoRawMode;
use tui::widgets::Widget;
use tui::*;

const MESSAGE: &str = "Merry Christmas !!";

struct Label<'a> {
    x: u16,
    y: u16,
    text: &'a str,
    style: style::Style,
}

impl<'a> Default for Label<'a> {
    fn default() -> Label<'a> {
        Label {
            x: 0,
            y: 0,
            text: "",
            style: style::Style::default(),
        }
    }
}

impl<'a> Label<'a> {
    fn text(&mut self, text: &'a str) -> &mut Label<'a> {
        self.text = text;
        self
    }
    fn position(&mut self, x: u16, y: u16) -> &mut Label<'a> {
        self.x = x;
        self.y = y;
        self
    }
    fn style(&mut self, style: style::Style) -> &mut Label<'a> {
        self.style = style;
        self
    }
}

impl<'a> Widget for Label<'a> {
    fn draw(&mut self, area: layout::Rect, buf: &mut buffer::Buffer) {
        buf.set_string(
            area.left() + self.x,
            area.top() + self.y,
            self.text,
            self.style,
        );
    }
}

fn main() {
    let stdout = io::stdout().into_raw_mode().unwrap();
    let stdout = termion::screen::AlternateScreen::from(stdout);
    let backend = backend::TermionBackend::new(stdout);
    let mut terminal = Terminal::new(backend).unwrap();
    terminal.hide_cursor();
    terminal
        .draw(|mut f| {
            let size = f.size();
            Label::default().text("Hello World !!").render(&mut f, size);
        })
        .unwrap();

    let stdin = io::stdin();
    for c in stdin.keys() {
        match c {
            Ok(termion::event::Key::Char('m')) => {
                terminal.clear();
                terminal
                    .draw(|mut f| {
                        let size = f.size();
                        let x = size.width / 2 - (MESSAGE.len() / 2) as u16;
                        let y = size.height / 2;
                        let style = style::Style::default().fg(style::Color::Blue);
                        Label::default()
                            .text(MESSAGE)
                            .position(x, y)
                            .style(style)
                            .render(&mut f, size);
                    })
                    .unwrap();
            }
            Ok(termion::event::Key::Ctrl('c')) => break,
            _ => {}
        }
    }
}