feat: curses instance can be passed to backend

Cargo.toml

@@ -55,11 +55,6 @@ name = "crossterm_demo"
 path = "examples/crossterm_demo.rs"
 required-features = ["crossterm"]
 
-[[example]]
-name = "curses"
-path = "examples/curses.rs"
-required-features = ["curses"]
-
 [[example]]
 name = "curses_demo"
 path = "examples/curses_demo.rs"

examples/curses_demo.rs

@@ -2,11 +2,12 @@ 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 easycurses;
 use tui::Terminal;
 
 use crate::demo::{ui, App};
@@ -23,13 +24,14 @@ fn main() -> Result<(), failure::Error> {
     let cli = Cli::from_args();
     stderrlog::new().quiet(!cli.log).verbosity(4).init()?;
 
-    let mut terminal = Terminal::new(CursesBackend::new().unwrap()).unwrap();
+    let mut backend = CursesBackend::new().ok_or(io::Error::new(io::ErrorKind::Other, ""))?;
-    terminal.clear().unwrap();
+    let curses = backend.get_curses_mut();
-    terminal.hide_cursor().unwrap();
+    curses.set_echo(false);
-    terminal
+    curses.set_input_timeout(easycurses::TimeoutMode::WaitUpTo(50));
-        .backend_mut()
+    curses.set_input_mode(easycurses::InputMode::RawCharacter);
-        .get_curses_window_mut()
+    curses.set_keypad_enabled(true);
-        .set_input_timeout(easycurses::TimeoutMode::WaitUpTo(50));
+    let mut terminal = Terminal::new(backend)?;
+    terminal.hide_cursor()?;
 
     let mut app = App::new("Curses demo");
 
@@ -37,7 +39,7 @@ fn main() -> Result<(), failure::Error> {
     let tick_rate = Duration::from_millis(cli.tick_rate);
     loop {
         ui::draw(&mut terminal, &app)?;
-        match terminal.backend_mut().get_curses_window_mut().get_input() {
+        match terminal.backend_mut().get_curses_mut().get_input() {
             Some(input) => {
                 match input {
                     easycurses::Input::Character(c) => {
@@ -60,7 +62,7 @@ fn main() -> Result<(), failure::Error> {
             }
             _ => {}
         };
-        terminal.backend_mut().get_curses_window_mut().flush_input();
+        terminal.backend_mut().get_curses_mut().flush_input();
         if last_tick.elapsed() > tick_rate {
             app.on_tick();
             last_tick = Instant::now();

src/backend/curses.rs

@@ -16,26 +16,20 @@ pub struct CursesBackend {
 }
 
 impl CursesBackend {
-    pub fn new() -> Result<CursesBackend, String> {
+    pub fn new() -> Option<CursesBackend> {
-        match easycurses::EasyCurses::initialize_system() {
+        let curses = easycurses::EasyCurses::initialize_system()?;
-            Some(mut curses) => {
+        Some(CursesBackend { curses })
-                curses.set_echo(false);
+    }
-                curses.set_input_timeout(easycurses::TimeoutMode::Never);
+
-                curses.set_input_mode(easycurses::InputMode::RawCharacter);
+    pub fn with_curses(curses: easycurses::EasyCurses) -> CursesBackend {
-                curses.set_keypad_enabled(true);
+        CursesBackend { curses }
-                Ok(CursesBackend { curses })
-            }
-            None => Err(String::from(
-                "Can't initialize curses, make sure it is not running already.",
-            )),
-        }
     }
 
-    pub fn get_curses_window(&self) -> &easycurses::EasyCurses {
+    pub fn get_curses(&self) -> &easycurses::EasyCurses {
         &self.curses
     }
 
-    pub fn get_curses_window_mut(&mut self) -> &mut easycurses::EasyCurses {
+    pub fn get_curses_mut(&mut self) -> &mut easycurses::EasyCurses {
         &mut self.curses
     }
 }