Fix the tests

examples/click.rs

@@ -1,13 +1,13 @@
 extern crate termion;
 
 use termion::event::{Key, Event, MouseEvent};
-use termion::input::TermRead;
+use termion::input::{TermRead, MouseTerminal};
 use termion::raw::IntoRawMode;
 use std::io::{Write, stdout, stdin};
 
 fn main() {
     let stdin = stdin();
-    let mut stdout = stdout().into_raw_mode().unwrap().with_mouse().unwrap();
+    let mut stdout = MouseTerminal::from(stdout().into_raw_mode().unwrap());
 
     write!(stdout, "{}{}q to exit. Click, click, click!", termion::clear::All, termion::cursor::Goto(1, 1)).unwrap();
     stdout.flush().unwrap();

examples/mouse.rs

@@ -1,13 +1,13 @@
 extern crate termion;
 
 use termion::event::{Key, Event, MouseEvent};
-use termion::input::TermRead;
+use termion::input::{TermRead, MouseTerminal};
 use termion::raw::IntoRawMode;
 use std::io::{Write, stdout, stdin};
 
 fn main() {
     let stdin = stdin();
-    let mut stdout = stdout().into_raw_mode().unwrap().with_mouse().unwrap();
+    let mut stdout = MouseTerminal::from(stdout().into_raw_mode().unwrap());
 
     write!(stdout, "{}{}q to exit. Type stuff, use alt, click around...", termion::clear::All, termion::cursor::Goto(1, 1)).unwrap();
 

src/event.rs

@@ -195,8 +195,8 @@ where I: Iterator<Item = Result<u8, Error>>
                                     let ref mut nums = str_buf.split(';');
 
                                     let cb = nums.next().unwrap().parse::<u16>().unwrap();
-                                    let cx = nums.next().unwrap().parse::<u16>().unwrap() - 1;
                                     let cy = nums.next().unwrap().parse::<u16>().unwrap() - 1;
+                                    let cx = nums.next().unwrap().parse::<u16>().unwrap() - 1;
 
                                     let event = match cb {
                                         32 => MouseEvent::Press(MouseButton::Left, cx, cy),

src/input.rs

@@ -1,11 +1,11 @@
 //! Input.
 
 use std::io::{self, Read, Write};
+use std::ops;
+
 use event::{parse_event, Event, Key};
-
 use raw::IntoRawMode;
 
-
 /// An iterator over input keys.
 pub struct Keys<I> {
     iter: Events<I>,
@@ -67,7 +67,6 @@ pub trait TermRead {
     }
 }
 
-
 impl<R: Read> TermRead for R {
     fn events(self) -> Events<io::Bytes<R>> {
         Events {
@@ -98,6 +97,57 @@ impl<R: Read> TermRead for R {
     }
 }
 
+/// A sequence of escape codes to enable terminal mouse support.
+const ENTER_MOUSE_SEQUENCE: &'static str = csi!("?1000h\x1b[?1002h\x1b[?1015h\x1b[?1006h");
+
+/// A sequence of escape codes to disable terminal mouse support.
+const EXIT_MOUSE_SEQUENCE: &'static str = csi!("?1006l\x1b[?1015l\x1b[?1002l\x1b[?1000l");
+
+/// A terminal with added mouse support.
+///
+/// This can be obtained through the `From` implementations.
+pub struct MouseTerminal<W: Write> {
+    term: W,
+}
+
+impl<W: Write> From<W> for MouseTerminal<W> {
+    fn from(mut from: W) -> MouseTerminal<W> {
+        from.write(ENTER_MOUSE_SEQUENCE.as_bytes()).unwrap();
+
+        MouseTerminal { term: from }
+    }
+}
+
+impl<W: Write> Drop for MouseTerminal<W> {
+    fn drop(&mut self) {
+        self.term.write(EXIT_MOUSE_SEQUENCE.as_bytes()).unwrap();
+    }
+}
+
+impl<W: Write> ops::Deref for MouseTerminal<W> {
+    type Target = W;
+
+    fn deref(&self) -> &W {
+        &self.term
+    }
+}
+
+impl<W: Write> ops::DerefMut for MouseTerminal<W> {
+    fn deref_mut(&mut self) -> &mut W {
+        &mut self.term
+    }
+}
+
+impl<W: Write> Write for MouseTerminal<W> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.term.write(buf)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.term.flush()
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
@@ -126,11 +176,11 @@ mod test {
         assert_eq!(i.next().unwrap().unwrap(), Event::Key(Key::Char('c')));
         assert_eq!(i.next().unwrap().unwrap(), Event::Key(Key::Backspace));
         assert_eq!(i.next().unwrap().unwrap(), Event::Key(Key::Left));
-        assert_eq!(i.next().unwrap().unwrap(), Event::Mouse(MouseEvent::Press(MouseButton::WheelUp, 1, 3)));
+        assert_eq!(i.next().unwrap().unwrap(), Event::Mouse(MouseEvent::Press(MouseButton::WheelUp, 4, 2)));
-        assert_eq!(i.next().unwrap().unwrap(), Event::Mouse(MouseEvent::Press(MouseButton::Left, 1, 3)));
+        assert_eq!(i.next().unwrap().unwrap(), Event::Mouse(MouseEvent::Press(MouseButton::Left, 4, 2)));
-        assert_eq!(i.next().unwrap().unwrap(), Event::Mouse(MouseEvent::Press(MouseButton::Left, 1, 3)));
+        assert_eq!(i.next().unwrap().unwrap(), Event::Mouse(MouseEvent::Press(MouseButton::Left, 3, 1)));
-        assert_eq!(i.next().unwrap().unwrap(), Event::Mouse(MouseEvent::Release(1, 3)));
+        assert_eq!(i.next().unwrap().unwrap(), Event::Mouse(MouseEvent::Release(4, 2)));
-        assert_eq!(i.next().unwrap().unwrap(), Event::Mouse(MouseEvent::Release(1, 3)));
+        assert_eq!(i.next().unwrap().unwrap(), Event::Mouse(MouseEvent::Release(3, 1)));
         assert_eq!(i.next().unwrap().unwrap(), Event::Key(Key::Char('b')));
         assert!(i.next().is_none());
     }

src/raw.rs

@@ -1,7 +1,7 @@
 //! Raw mode.
 
 use std::io::{self, Write};
-use std::ops::{Deref, DerefMut};
+use std::ops;
 
 /// A terminal restorer, which keeps the previous state of the terminal, and restores it, when
 /// dropped.
@@ -28,17 +28,6 @@ pub struct RawTerminal<W: Write> {
     output: W,
 }
 
-#[cfg(not(target_os = "redox"))]
-impl<W> RawTerminal<W>
-    where W: Write
-{
-    /// Enable mouse support.
-    pub fn with_mouse(mut self) -> io::Result<MouseTerminal<W>> {
-        try!(self.write(ENTER_MOUSE_SEQUENCE));
-        Ok(MouseTerminal { term: self })
-    }
-}
-
 #[cfg(not(target_os = "redox"))]
 impl<W: Write> Drop for RawTerminal<W> {
     fn drop(&mut self) {
@@ -47,7 +36,7 @@ impl<W: Write> Drop for RawTerminal<W> {
     }
 }
 
-impl<W: Write> Deref for RawTerminal<W> {
+impl<W: Write> ops::Deref for RawTerminal<W> {
     type Target = W;
 
     fn deref(&self) -> &W {
@@ -55,7 +44,7 @@ impl<W: Write> Deref for RawTerminal<W> {
     }
 }
 
-impl<W: Write> DerefMut for RawTerminal<W> {
+impl<W: Write> ops::DerefMut for RawTerminal<W> {
     fn deref_mut(&mut self) -> &mut W {
         &mut self.output
     }
@@ -118,56 +107,6 @@ impl<W: Write> IntoRawMode for W {
     }
 }
 
-/// A sequence of escape codes to enable terminal mouse support.
-const ENTER_MOUSE_SEQUENCE: &'static [u8] = b"\x1b[?1000h\x1b[?1002h\x1b[?1015h\x1b[?1006h";
-
-/// A sequence of escape codes to disable terminal mouse support.
-const EXIT_MOUSE_SEQUENCE: &'static [u8] = b"\x1b[?1006l\x1b[?1015l\x1b[?1002l\x1b[?1000l";
-
-/// A `RawTerminal` with added mouse support.
-///
-/// To get such a terminal handle use `RawTerminal`'s
-/// [`with_mouse()`](../termion/struct.RawTerminal.html#method.with_mouse) method.
-#[cfg(not(target_os = "redox"))]
-pub struct MouseTerminal<W: Write> {
-    term: RawTerminal<W>,
-}
-
-#[cfg(not(target_os = "redox"))]
-impl<W: Write> Drop for MouseTerminal<W> {
-    fn drop(&mut self) {
-        self.term.write(EXIT_MOUSE_SEQUENCE).unwrap();
-    }
-}
-
-#[cfg(not(target_os = "redox"))]
-impl<W: Write> Deref for MouseTerminal<W> {
-    type Target = W;
-
-    fn deref(&self) -> &W {
-        self.term.deref()
-    }
-}
-
-#[cfg(not(target_os = "redox"))]
-impl<W: Write> DerefMut for MouseTerminal<W> {
-    fn deref_mut(&mut self) -> &mut W {
-        self.term.deref_mut()
-    }
-}
-
-#[cfg(not(target_os = "redox"))]
-impl<W: Write> Write for MouseTerminal<W> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.term.write(buf)
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        self.term.flush()
-    }
-}
-
-
 #[cfg(test)]
 mod test {
     use super::*;
@@ -179,10 +118,4 @@ mod test {
 
         out.write(b"this is a test, muahhahahah").unwrap();
     }
-
-    #[test]
-    fn test_enable_mouse() {
-        let mut out = stdout().into_raw_mode().unwrap().with_mouse().unwrap();
-        out.write(b"abcde\x1B[<1;1;0;Mfgh").unwrap();
-    }
 }