collect everything under a single reader/writer object

2 files changed, 72 insertions, 34 deletions

diff --git a/src/term.rs b/src/term.rs
index 88c34e7..4754d7e 100644
--- a/src/term.rs
+++ b/src/term.rs
@@ -5,25 +5,66 @@
 use core::libc::c_int;
 
 pub use ios::{cooked,cbreak,raw,echo,size};
-use info::{init,escape,escape2};
+use info::{escape,escape2};
 use util::Trie;
 
+struct Term {
+    priv r: Reader,
+    priv w: Writer,
+}
+
+pub fn Term (cleanup: bool) -> Term {
+    info::init();
+    io::print(escape("smkx"));
+    Term { r: Reader(cleanup), w: Writer(cleanup) }
+}
+
+impl Term {
+    pub fn clear (&mut self) {
+        self.w.clear();
+    }
+
+    pub fn move (&mut self, col: uint, row: uint) {
+        self.w.move(col, row);
+    }
+
+    pub fn cursor (&mut self, enabled: bool) {
+        self.w.cursor(enabled);
+    }
+
+    pub fn alternate_screen (&mut self, enabled: bool) {
+        self.w.alternate_screen(enabled);
+    }
+
+    pub fn write (&mut self, text: &str) {
+        self.w.write(text);
+    }
+
+    pub fn flush (&mut self) {
+        self.w.flush();
+    }
+
+    pub fn read (&mut self) -> Option<Keypress> {
+        self.w.flush();
+        self.r.read()
+    }
+}
+
 struct Writer {
     priv buf: ~str,
     priv cleanup: bool,
 }
 
-pub fn Writer (cleanup: bool) -> Writer {
-    init();
+fn Writer (cleanup: bool) -> Writer {
     Writer { buf: ~"", cleanup: cleanup }
 }
 
 impl Writer {
-    pub fn clear (&mut self) {
+    fn clear (&mut self) {
         str::push_str(&mut self.buf, escape("clear"));
     }
 
-    pub fn move (&mut self, col: uint, row: uint) {
+    fn move (&mut self, col: uint, row: uint) {
         if col == 0u && row == 0u {
             str::push_str(&mut self.buf, escape("home"));
         }
@@ -33,7 +74,7 @@ impl Writer {
         }
     }
 
-    pub fn cursor (&mut self, enabled: bool) {
+    fn cursor (&mut self, enabled: bool) {
         if enabled {
             str::push_str(&mut self.buf, escape("civis"));
         }
@@ -42,7 +83,7 @@ impl Writer {
         }
     }
 
-    pub fn alternate_screen (&mut self, enable: bool) {
+    fn alternate_screen (&mut self, enable: bool) {
         if enable {
             str::push_str(&mut self.buf, escape("smcup"));
         }
@@ -51,11 +92,11 @@ impl Writer {
         }
     }
 
-    pub fn write (&mut self, text: &str) {
+    fn write (&mut self, text: &str) {
         str::push_str(&mut self.buf, text);
     }
 
-    pub fn flush (&mut self) {
+    fn flush (&mut self) {
         io::print(self.buf);
         io::stdout().flush();
         self.buf = ~"";
@@ -97,12 +138,11 @@ struct Reader {
 }
 
 pub fn Reader (cleanup: bool) -> Reader {
-    io::print(escape("smkx"));
     Reader { escapes: build_escapes_trie(), buf: ~"", cleanup: cleanup }
 }
 
 impl Reader {
-    pub fn read (&mut self) -> Option<Keypress> {
+    fn read (&mut self) -> Option<Keypress> {
         if str::len(self.buf) > 0 {
             return Some(self.next_key());
         }
diff --git a/test/rl.rs b/test/rl.rs
index 1915c43..7c04629 100644
--- a/test/rl.rs
+++ b/test/rl.rs
@@ -1,53 +1,51 @@
 extern mod term;
 use term::{KeyCharacter,KeyEscape,KeyUp,KeyDown,KeyLeft,KeyRight};
 
-fn term_app (body: &fn (r: &mut term::Reader, w: &mut term::Writer)) {
-    let mut writer = term::Writer(true);
-    let mut reader = term::Reader(true);
+fn term_app (body: &fn (r: &mut term::Term)) {
+    let mut term = term::Term(true);
     do term::ios::preserve {
-        writer.alternate_screen(true);
-        body(&mut reader, &mut writer);
+        term.alternate_screen(true);
+        body(&mut term);
     }
 }
 
-fn draw_map (w: &mut term::Writer, rows: uint, cols: uint) {
+fn draw_map (term: &mut term::Term, rows: uint, cols: uint) {
     for uint::range(0, rows) |i| {
-        w.move(0, i);
-        w.write(str::repeat(".", cols));
+        term.move(0, i);
+        term.write(str::repeat(".", cols));
     }
 }
 
-fn draw_character (w: &mut term::Writer, x: uint, y: uint) {
-    w.move(x, y);
-    w.write("@");
-    w.move(x, y);
+fn draw_character (term: &mut term::Term, x: uint, y: uint) {
+    term.move(x, y);
+    term.write("@");
+    term.move(x, y);
 }
 
-fn draw_ground (w: &mut term::Writer, x: uint, y: uint) {
-    w.move(x, y);
-    w.write(".");
+fn draw_ground (term: &mut term::Term, x: uint, y: uint) {
+    term.move(x, y);
+    term.write(".");
 }
 
 fn main () {
     let (cols, rows) = term::size();
 
-    do term_app |r, w| {
+    do term_app |term| {
         term::cbreak();
         term::echo(false);
-        w.clear();
+        term.clear();
 
-        draw_map(w, rows, cols);
+        draw_map(term, rows, cols);
 
         let mut (x, y) = (0u, 0u);
         let mut cursor = true;
         loop {
-            draw_character(w, x, y);
-            w.flush();
-            let k = match r.read() {
+            draw_character(term, x, y);
+            let k = match term.read() {
                 Some(key) => key,
                 None      => break,
             };
-            draw_ground(w, x, y);
+            draw_ground(term, x, y);
 
             match k {
                 KeyCharacter('q') | KeyEscape => { break }
@@ -57,7 +55,7 @@ fn main () {
                 KeyCharacter('k') | KeyUp    if y > 0        => { y -= 1 }
                 KeyCharacter('l') | KeyRight if x < cols - 1 => { x += 1 }
 
-                KeyCharacter(' ') => { w.cursor(cursor); cursor = !cursor }
+                KeyCharacter(' ') => { term.cursor(cursor); cursor = !cursor }
 
                 _   => { }
             }