adjust the way window contents are reported

contents and contents_formatted now only allow getting the entire
terminal contents, and for any other uses we now provide rows and
rows_formatted.

the reasoning here is that it wasn't particularly useful to return
newline (or crlf) separated lines when not drawing the full terminal,
since it's not like you can send those to the terminal in any meaningful
way anyway (like, if you wanted to draw a subset of the terminal state,
you'll almost certainly need to be doing explicit positioning on your
own, since crlf is only actually correct if you're drawing the screen
subset in the upper left hand corner of the screen). with this, you can
draw each (subset of a) line individually, and reposition the cursor in
whatever way makes sense in between drawing the lines.

14 files changed, 552 insertions, 315 deletions

diff --git a/src/grid.rs b/src/grid.rs
index d7abbad..14a3eae 100644
--- a/src/grid.rs
+++ b/src/grid.rs
@@ -123,48 +123,33 @@ impl Grid {
             .expect("cursor not pointing to a cell")
     }
 
-    pub fn contents(
-        &self,
-        row_start: u16,
-        col_start: u16,
-        row_end: u16,
-        col_end: u16,
-    ) -> String {
+    pub fn contents(&self) -> String {
         let mut contents = String::new();
-        let row_start = row_start as usize;
-        let row_end = row_end as usize;
-        for row in self.rows().skip(row_start).take(row_end - row_start + 1) {
-            contents += &row.contents(col_start, col_end);
+        for row in self.rows() {
+            contents += &row.contents(0, self.size.cols);
+            if !row.wrapped() {
+                contents += "\n";
+            }
         }
         contents.trim_end().to_string()
     }
 
-    pub fn contents_formatted(
-        &self,
-        row_start: u16,
-        col_start: u16,
-        row_end: u16,
-        col_end: u16,
-    ) -> Vec<u8> {
+    pub fn contents_formatted(&self) -> Vec<u8> {
         let mut contents = vec![];
         let mut prev_attrs = crate::attrs::Attrs::default();
-        let row_start = row_start as usize;
-        let row_end = row_end as usize;
-        for row in self.rows().skip(row_start).take(row_end - row_start + 1) {
+        for row in self.rows() {
             let (mut new_contents, new_attrs) =
-                row.contents_formatted(col_start, col_end, prev_attrs);
+                row.contents_formatted(0, self.size.cols, prev_attrs);
             contents.append(&mut new_contents);
+            if !row.wrapped() {
+                contents.extend(b"\r\n");
+            }
             prev_attrs = new_attrs;
         }
 
-        let mut idx = None;
-        for (i, b) in contents.iter().enumerate().rev() {
-            if !(*b as char).is_whitespace() {
-                idx = Some(i + 1);
-                break;
-            }
+        while contents.ends_with(b"\r\n") {
+            contents.truncate(contents.len() - 2);
         }
-        contents.truncate(idx.unwrap_or(0));
         contents
     }
 
diff --git a/src/row.rs b/src/row.rs
index cf668ce..ade6408 100644
--- a/src/row.rs
+++ b/src/row.rs
@@ -21,6 +21,10 @@ impl Row {
         self.wrapped = false;
     }
 
+    fn cells(&self) -> impl Iterator<Item = &crate::cell::Cell> {
+        self.cells.iter()
+    }
+
     pub fn cells_mut(
         &mut self,
     ) -> impl Iterator<Item = &mut crate::cell::Cell> {
@@ -59,84 +63,78 @@ impl Row {
         self.wrapped
     }
 
-    pub fn contents(&self, col_start: u16, col_end: u16) -> String {
+    pub fn contents(&self, start: u16, width: u16) -> String {
         let mut prev_was_wide = false;
         let mut contents = String::new();
-        if let Some(max_col) = self.max_col() {
-            for col in col_start..=(col_end.min(max_col)) {
-                if prev_was_wide {
-                    prev_was_wide = false;
-                    continue;
-                }
-
-                let cell = &self.cells[col as usize];
-                let cell_contents = cell.contents();
-                let cell_contents = if cell_contents == "" {
-                    " "
-                } else {
-                    cell_contents
-                };
-                contents += cell_contents;
-                prev_was_wide = cell.is_wide();
+
+        for cell in self
+            .cells()
+            .skip(start as usize)
+            .take(width.min(self.content_width(start)) as usize)
+        {
+            if prev_was_wide {
+                prev_was_wide = false;
+                continue;
             }
+
+            contents += if cell.has_contents() {
+                cell.contents()
+            } else {
+                " "
+            };
+            prev_was_wide = cell.is_wide();
         }
-        if !self.wrapped {
-            contents += "\n";
-        }
-        contents
+
+        contents.trim_end().to_string()
     }
 
     pub fn contents_formatted(
         &self,
-        col_start: u16,
-        col_end: u16,
+        start: u16,
+        width: u16,
         attrs: crate::attrs::Attrs,
     ) -> (Vec<u8>, crate::attrs::Attrs) {
         let mut prev_was_wide = false;
         let mut contents = vec![];
         let mut prev_attrs = attrs;
-        if let Some(max_col) = self.max_col() {
-            for col in col_start..=(col_end.min(max_col)) {
-                if prev_was_wide {
-                    prev_was_wide = false;
-                    continue;
-                }
-
-                let cell = &self.cells[col as usize];
-
-                let attrs = cell.attrs();
-                if &prev_attrs != attrs {
-                    contents.append(&mut attrs.escape_code_diff(&prev_attrs));
-                    prev_attrs = *attrs;
-                }
-
-                let cell_contents = cell.contents();
-                let cell_contents = if cell_contents == "" {
-                    "\x1b[C"
-                } else {
-                    cell_contents
-                };
-                contents.extend(cell_contents.as_bytes());
-
-                prev_was_wide = cell.is_wide();
+
+        for cell in self
+            .cells()
+            .skip(start as usize)
+            .take(width.min(self.content_width(start)) as usize)
+        {
+            if prev_was_wide {
+                prev_was_wide = false;
+                continue;
             }
+
+            let attrs = cell.attrs();
+            if &prev_attrs != attrs {
+                contents.append(&mut attrs.escape_code_diff(&prev_attrs));
+                prev_attrs = *attrs;
+            }
+
+            contents.extend(if cell.has_contents() {
+                cell.contents().as_bytes()
+            } else {
+                b"\x1b[C"
+            });
+
+            prev_was_wide = cell.is_wide();
         }
-        if !self.wrapped {
-            contents.extend(b"\r\n");
-        }
+
         (contents, prev_attrs)
     }
 
-    fn max_col(&self) -> Option<u16> {
-        let mut prev_was_wide = false;
-        // XXX very inefficient
-        let mut max_col = None;
-        for (col, cell) in self.cells.iter().enumerate() {
-            if cell.has_contents() || prev_was_wide {
-                max_col = Some(col.try_into().unwrap());
-                prev_was_wide = cell.is_wide();
+    fn content_width(&self, start: u16) -> u16 {
+        for (col, cell) in
+            self.cells.iter().skip(start as usize).enumerate().rev()
+        {
+            if cell.has_contents() {
+                let width: u16 = col.try_into().unwrap();
+                return width + 1;
             }
         }
-        max_col
+        0
     }
 }
diff --git a/src/screen.rs b/src/screen.rs
index a1bf53b..dd30b19 100644
--- a/src/screen.rs
+++ b/src/screen.rs
@@ -122,38 +122,65 @@ impl Screen {
         (size.rows, size.cols)
     }
 
-    /// Returns the text contents of the subset of the terminal given by the
-    /// parameters.
+    /// Returns the text contents of the terminal.
     ///
     /// This will not include any formatting information, and will be in plain
     /// text format.
-    pub fn contents(
+    pub fn contents(&self) -> String {
+        self.grid().contents()
+    }
+
+    /// Returns the text contents of the terminal by row, restricted to the
+    /// given subset of columns.
+    ///
+    /// This will not include any formatting information, and will be in plain
+    /// text format.
+    ///
+    /// Newlines will not be included.
+    pub fn rows(
         &self,
-        row_start: u16,
-        col_start: u16,
-        row_end: u16,
-        col_end: u16,
-    ) -> String {
-        self.grid().contents(row_start, col_start, row_end, col_end)
+        start: u16,
+        width: u16,
+    ) -> impl Iterator<Item = String> + '_ {
+        self.grid()
+            .rows()
+            .map(move |row| row.contents(start, width))
     }
 
-    /// Returns the formatted contents of the subset of the terminal given by
-    /// the parameters.
+    /// Returns the formatted contents of the terminal.
     ///
     /// Formatting information will be included inline as terminal escape
     /// codes. The result will be suitable for feeding directly to a raw
     /// terminal parser, and will result in the same visual output. Internal
     /// terminal modes (such as application keypad mode or alternate screen
     /// mode) will not be included here.
-    pub fn contents_formatted(
+    pub fn contents_formatted(&self) -> Vec<u8> {
+        self.grid().contents_formatted()
+    }
+
+    /// Returns the formatted contents of the terminal by row, restricted to
+    /// the given subset of columns.
+    ///
+    /// Formatting information will be included inline as terminal escape
+    /// codes. The result will be suitable for feeding directly to a raw
+    /// terminal parser, and will result in the same visual output. Internal
+    /// terminal modes (such as application keypad mode or alternate screen
+    /// mode) will not be included here.
+    ///
+    /// CRLF at the end of lines will not be included.
+    pub fn rows_formatted(
         &self,
-        row_start: u16,
-        col_start: u16,
-        row_end: u16,
-        col_end: u16,
-    ) -> Vec<u8> {
-        self.grid()
-            .contents_formatted(row_start, col_start, row_end, col_end)
+        start: u16,
+        width: u16,
+    ) -> impl Iterator<Item = Vec<u8>> + '_ {
+        self.grid().rows().map(move |row| {
+            let (contents, _) = row.contents_formatted(
+                start,
+                width,
+                crate::attrs::Attrs::default(),
+            );
+            contents
+        })
     }
 
     /// Returns the `Cell` object at the given location in the terminal, if it
diff --git a/tests/basic.rs b/tests/basic.rs
index 4478218..1d30ddf 100644
--- a/tests/basic.rs
+++ b/tests/basic.rs
@@ -9,7 +9,7 @@ fn process_text() {
     let mut parser = vt100::Parser::new(24, 80);
     let input = b"foo\x1b[31m\x1b[32mb\x1b[3;7;42ma\x1b[23mr";
     parser.process(input);
-    assert_eq!(parser.screen().contents(0, 0, 0, 50), "foobar");
+    assert_eq!(parser.screen().contents(), "foobar");
 }
 
 #[test]
@@ -47,22 +47,13 @@ fn set_size() {
 
     parser.screen_mut().set_size(34, 8);
     parser.process(b"\x1bc01234567890123456789");
-    assert_eq!(
-        parser.screen().contents(0, 0, 33, 7),
-        "01234567890123456789"
-    );
+    assert_eq!(parser.screen().contents(), "01234567890123456789");
 
     parser.screen_mut().set_size(24, 80);
-    assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
-        "01234567\n89012345\n6789"
-    );
+    assert_eq!(parser.screen().contents(), "01234567\n89012345\n6789");
 
     parser.screen_mut().set_size(34, 8);
-    assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
-        "01234567\n89012345\n6789"
-    );
+    assert_eq!(parser.screen().contents(), "01234567\n89012345\n6789");
 }
 
 #[test]
diff --git a/tests/control.rs b/tests/control.rs
index 03352b7..6f9c5b4 100644
--- a/tests/control.rs
+++ b/tests/control.rs
@@ -19,7 +19,7 @@ fn bs() {
     assert_eq!(parser.screen().cell(0, 2).unwrap().contents(), "a");
     assert_eq!(parser.screen().cell(0, 3).unwrap().contents(), "");
     assert_eq!(parser.screen().cell(1, 0).unwrap().contents(), "");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "faa");
+    assert_eq!(parser.screen().contents(), "faa");
 
     parser.process(b"\r\nquux\x08\x08\x08\x08\x08\x08bar");
     assert_eq!(parser.screen().cell(1, 0).unwrap().contents(), "b");
@@ -28,7 +28,7 @@ fn bs() {
     assert_eq!(parser.screen().cell(1, 3).unwrap().contents(), "x");
     assert_eq!(parser.screen().cell(1, 4).unwrap().contents(), "");
     assert_eq!(parser.screen().cell(2, 0).unwrap().contents(), "");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "faa\nbarx");
+    assert_eq!(parser.screen().contents(), "faa\nbarx");
 }
 
 #[test]
@@ -48,7 +48,7 @@ fn tab() {
     assert_eq!(parser.screen().cell(0, 9).unwrap().contents(), "a");
     assert_eq!(parser.screen().cell(0, 10).unwrap().contents(), "r");
     assert_eq!(parser.screen().cell(0, 11).unwrap().contents(), "");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "foo     bar");
+    assert_eq!(parser.screen().contents(), "foo     bar");
 }
 
 fn lf_with(b: u8) {
@@ -68,7 +68,7 @@ fn lf_with(b: u8) {
     assert_eq!(parser.screen().cell(1, 4).unwrap().contents(), "a");
     assert_eq!(parser.screen().cell(1, 5).unwrap().contents(), "r");
     assert_eq!(parser.screen().cell(1, 6).unwrap().contents(), "");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "foo\n   bar");
+    assert_eq!(parser.screen().contents(), "foo\n   bar");
 }
 
 #[test]
@@ -97,5 +97,5 @@ fn cr() {
     assert_eq!(parser.screen().cell(0, 3).unwrap().contents(), "o");
     assert_eq!(parser.screen().cell(0, 4).unwrap().contents(), "");
     assert_eq!(parser.screen().cell(1, 0).unwrap().contents(), "");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "baro");
+    assert_eq!(parser.screen().contents(), "baro");
 }
diff --git a/tests/csi.rs b/tests/csi.rs
index 85bbcab..1310dac 100644
--- a/tests/csi.rs
+++ b/tests/csi.rs
@@ -91,68 +91,68 @@ fn relative_movement() {
 #[test]
 fn ed() {
     let mut parser = vt100::Parser::new(24, 80);
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "");
+    assert_eq!(parser.screen().contents(), "");
 
     parser.process(b"foo\x1b[5;5Hbar\x1b[10;10Hbaz\x1b[20;20Hquux");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "foo\n\n\n\n    bar\n\n\n\n\n         baz\n\n\n\n\n\n\n\n\n\n                   quux");
+    assert_eq!(parser.screen().contents(), "foo\n\n\n\n    bar\n\n\n\n\n         baz\n\n\n\n\n\n\n\n\n\n                   quux");
 
     parser.process(b"\x1b[10;12H\x1b[0J");
     assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
+        parser.screen().contents(),
         "foo\n\n\n\n    bar\n\n\n\n\n         ba"
     );
 
     parser.process(b"\x1b[5;6H\x1b[1J");
     assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
+        parser.screen().contents(),
         "\n\n\n\n      r\n\n\n\n\n         ba"
     );
 
     parser.process(b"\x1b[7;7H\x1b[2J");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "");
+    assert_eq!(parser.screen().contents(), "");
 
     parser.process(b"\x1b[2J\x1b[H");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "");
+    assert_eq!(parser.screen().contents(), "");
 
     parser.process(b"foo\x1b[5;5Hbar\x1b[10;10Hbaz\x1b[20;20Hquux");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "foo\n\n\n\n    bar\n\n\n\n\n         baz\n\n\n\n\n\n\n\n\n\n                   quux");
+    assert_eq!(parser.screen().contents(), "foo\n\n\n\n    bar\n\n\n\n\n         baz\n\n\n\n\n\n\n\n\n\n                   quux");
 
     parser.process(b"\x1b[10;12H\x1b[J");
     assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
+        parser.screen().contents(),
         "foo\n\n\n\n    bar\n\n\n\n\n         ba"
     );
 
     parser.process(b"\x1b[2J\x1b[H");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "");
+    assert_eq!(parser.screen().contents(), "");
 
     parser.process(b"foo\x1b[5;5Hbar\x1b[10;10Hbaz\x1b[20;20Hquux");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "foo\n\n\n\n    bar\n\n\n\n\n         baz\n\n\n\n\n\n\n\n\n\n                   quux");
+    assert_eq!(parser.screen().contents(), "foo\n\n\n\n    bar\n\n\n\n\n         baz\n\n\n\n\n\n\n\n\n\n                   quux");
 
     parser.process(b"\x1b[10;12H\x1b[?0J");
     assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
+        parser.screen().contents(),
         "foo\n\n\n\n    bar\n\n\n\n\n         ba"
     );
 
     parser.process(b"\x1b[5;6H\x1b[?1J");
     assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
+        parser.screen().contents(),
         "\n\n\n\n      r\n\n\n\n\n         ba"
     );
 
     parser.process(b"\x1b[7;7H\x1b[?2J");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "");
+    assert_eq!(parser.screen().contents(), "");
 
     parser.process(b"\x1b[2J\x1b[H");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "");
+    assert_eq!(parser.screen().contents(), "");
 
     parser.process(b"foo\x1b[5;5Hbar\x1b[10;10Hbaz\x1b[20;20Hquux");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "foo\n\n\n\n    bar\n\n\n\n\n         baz\n\n\n\n\n\n\n\n\n\n                   quux");
+    assert_eq!(parser.screen().contents(), "foo\n\n\n\n    bar\n\n\n\n\n         baz\n\n\n\n\n\n\n\n\n\n                   quux");
 
     parser.process(b"\x1b[10;12H\x1b[?J");
     assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
+        parser.screen().contents(),
         "foo\n\n\n\n    bar\n\n\n\n\n         ba"
     );
 }
@@ -160,71 +160,71 @@ fn ed() {
 #[test]
 fn el() {
     let mut parser = vt100::Parser::new(24, 80);
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "");
+    assert_eq!(parser.screen().contents(), "");
 
     parser.process(b"foo\x1b[5;5Hbarbar\x1b[10;10Hbazbaz\x1b[20;20Hquux");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "foo\n\n\n\n    barbar\n\n\n\n\n         bazbaz\n\n\n\n\n\n\n\n\n\n                   quux");
+    assert_eq!(parser.screen().contents(), "foo\n\n\n\n    barbar\n\n\n\n\n         bazbaz\n\n\n\n\n\n\n\n\n\n                   quux");
 
     parser.process(b"\x1b[5;8H\x1b[0K");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "foo\n\n\n\n    bar\n\n\n\n\n         bazbaz\n\n\n\n\n\n\n\n\n\n                   quux");
+    assert_eq!(parser.screen().contents(), "foo\n\n\n\n    bar\n\n\n\n\n         bazbaz\n\n\n\n\n\n\n\n\n\n                   quux");
 
     parser.process(b"\x1b[10;12H\x1b[1K");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "foo\n\n\n\n    bar\n\n\n\n\n            baz\n\n\n\n\n\n\n\n\n\n                   quux");
+    assert_eq!(parser.screen().contents(), "foo\n\n\n\n    bar\n\n\n\n\n            baz\n\n\n\n\n\n\n\n\n\n                   quux");
 
     parser.process(b"\x1b[20;22H\x1b[2K");
     assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
+        parser.screen().contents(),
         "foo\n\n\n\n    bar\n\n\n\n\n            baz"
     );
 
     parser.process(b"\x1b[1;2H\x1b[K");
     assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
+        parser.screen().contents(),
         "f\n\n\n\n    bar\n\n\n\n\n            baz"
     );
 
     parser.process(b"\x1b[2J\x1b[H");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "");
+    assert_eq!(parser.screen().contents(), "");
 
     parser.process(b"foo\x1b[5;5Hbarbar\x1b[10;10Hbazbaz\x1b[20;20Hquux");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "foo\n\n\n\n    barbar\n\n\n\n\n         bazbaz\n\n\n\n\n\n\n\n\n\n                   quux");
+    assert_eq!(parser.screen().contents(), "foo\n\n\n\n    barbar\n\n\n\n\n         bazbaz\n\n\n\n\n\n\n\n\n\n                   quux");
 
     parser.process(b"\x1b[5;8H\x1b[?0K");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "foo\n\n\n\n    bar\n\n\n\n\n         bazbaz\n\n\n\n\n\n\n\n\n\n                   quux");
+    assert_eq!(parser.screen().contents(), "foo\n\n\n\n    bar\n\n\n\n\n         bazbaz\n\n\n\n\n\n\n\n\n\n                   quux");
 
     parser.process(b"\x1b[10;12H\x1b[?1K");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "foo\n\n\n\n    bar\n\n\n\n\n            baz\n\n\n\n\n\n\n\n\n\n                   quux");
+    assert_eq!(parser.screen().contents(), "foo\n\n\n\n    bar\n\n\n\n\n            baz\n\n\n\n\n\n\n\n\n\n                   quux");
 
     parser.process(b"\x1b[20;22H\x1b[?2K");
     assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
+        parser.screen().contents(),
         "foo\n\n\n\n    bar\n\n\n\n\n            baz"
     );
 
     parser.process(b"\x1b[1;2H\x1b[?K");
     assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
+        parser.screen().contents(),
         "f\n\n\n\n    bar\n\n\n\n\n            baz"
     );
 
     parser.process(b"\x1b[2J\x1b[H");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "");
+    assert_eq!(parser.screen().contents(), "");
 
     parser.process(b"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
     assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
+        parser.screen().contents(),
         "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
     );
 
     parser.process(b"\x1b[1;21H\x1b[K");
     assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
+        parser.screen().contents(),
         "12345678901234567890\n12345678901234567890"
     );
 
     parser.process(b"\x1b[1;10H\x1b[1K");
     assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
+        parser.screen().contents(),
         "          1234567890\n12345678901234567890"
     );
 }
@@ -232,158 +232,146 @@ fn el() {
 #[test]
 fn ich_dch_ech() {
     let mut parser = vt100::Parser::new(24, 80);
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "");
+    assert_eq!(parser.screen().contents(), "");
 
     parser.process(b"\x1b[10;10Hfoobar");
     assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
+        parser.screen().contents(),
         "\n\n\n\n\n\n\n\n\n         foobar"
     );
 
     parser.process(b"\x1b[10;12H\x1b[3@");
     assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
+        parser.screen().contents(),
         "\n\n\n\n\n\n\n\n\n         fo   obar"
     );
     assert_eq!(parser.screen().cursor_position(), (9, 11));
 
     parser.process(b"\x1b[4P");
     assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
+        parser.screen().contents(),
         "\n\n\n\n\n\n\n\n\n         fobar"
     );
     assert_eq!(parser.screen().cursor_position(), (9, 11));
 
     parser.process(b"\x1b[100@");
-    assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
-        "\n\n\n\n\n\n\n\n\n         fo"
-    );
+    assert_eq!(parser.screen().contents(), "\n\n\n\n\n\n\n\n\n         fo");
     assert_eq!(parser.screen().cursor_position(), (9, 11));
 
     parser.process(b"obar");
     assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
+        parser.screen().contents(),
         "\n\n\n\n\n\n\n\n\n         foobar"
     );
     assert_eq!(parser.screen().cursor_position(), (9, 15));
 
     parser.process(b"\x1b[10;12H\x1b[100P");
-    assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
-        "\n\n\n\n\n\n\n\n\n         fo"
-    );
+    assert_eq!(parser.screen().contents(), "\n\n\n\n\n\n\n\n\n         fo");
     assert_eq!(parser.screen().cursor_position(), (9, 11));
 
     parser.process(b"obar");
     assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
+        parser.screen().contents(),
         "\n\n\n\n\n\n\n\n\n         foobar"
     );
     assert_eq!(parser.screen().cursor_position(), (9, 15));
 
     parser.process(b"\x1b[10;13H\x1b[X");
     assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
+        parser.screen().contents(),
         "\n\n\n\n\n\n\n\n\n         foo ar"
     );
     assert_eq!(parser.screen().cursor_position(), (9, 12));
 
     parser.process(b"\x1b[10;11H\x1b[4X");
     assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
+        parser.screen().contents(),
         "\n\n\n\n\n\n\n\n\n         f    r"
     );
     assert_eq!(parser.screen().cursor_position(), (9, 10));
 
     parser.process(b"\x1b[10;11H\x1b[400X");
-    assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
-        "\n\n\n\n\n\n\n\n\n         f"
-    );
+    assert_eq!(parser.screen().contents(), "\n\n\n\n\n\n\n\n\n         f");
     assert_eq!(parser.screen().cursor_position(), (9, 10));
 }
 
 #[test]
 fn il_dl() {
     let mut parser = vt100::Parser::new(24, 80);
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "");
+    assert_eq!(parser.screen().contents(), "");
 
     parser.process(b"\x1b[10;10Hfoobar\x1b[3D");
     assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
+        parser.screen().contents(),
         "\n\n\n\n\n\n\n\n\n         foobar"
     );
     assert_eq!(parser.screen().cursor_position(), (9, 12));
 
     parser.process(b"\x1b[L");
     assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
+        parser.screen().contents(),
         "\n\n\n\n\n\n\n\n\n\n         foobar"
     );
     assert_eq!(parser.screen().cursor_position(), (9, 12));
 
     parser.process(b"\x1b[3L");
     assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
+        parser.screen().contents(),
         "\n\n\n\n\n\n\n\n\n\n\n\n\n         foobar"
     );
     assert_eq!(parser.screen().cursor_position(), (9, 12));
 
     parser.process(b"\x1b[500L");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "");
+    assert_eq!(parser.screen().contents(), "");
     assert_eq!(parser.screen().cursor_position(), (9, 12));
 
     parser.process(b"\x1b[10;10Hfoobar\x1b[3D\x1b[6A");
     assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
+        parser.screen().contents(),
         "\n\n\n\n\n\n\n\n\n         foobar"
     );
     assert_eq!(parser.screen().cursor_position(), (3, 12));
 
     parser.process(b"\x1b[M");
     assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
+        parser.screen().contents(),
         "\n\n\n\n\n\n\n\n         foobar"
     );
     assert_eq!(parser.screen().cursor_position(), (3, 12));
 
     parser.process(b"\x1b[3M");
-    assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
-        "\n\n\n\n\n         foobar"
-    );
+    assert_eq!(parser.screen().contents(), "\n\n\n\n\n         foobar");
     assert_eq!(parser.screen().cursor_position(), (3, 12));
 
     parser.process(b"\x1b[500M");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "");
+    assert_eq!(parser.screen().contents(), "");
     assert_eq!(parser.screen().cursor_position(), (3, 12));
 }
 
 #[test]
 fn scroll() {
     let mut parser = vt100::Parser::new(24, 80);
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "");
+    assert_eq!(parser.screen().contents(), "");
 
     parser.process(b"1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
+    assert_eq!(parser.screen().contents(), "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
 
     parser.process(b"\x1b[15;15H");
     assert_eq!(parser.screen().cursor_position(), (14, 14));
 
     parser.process(b"\x1b[S");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
+    assert_eq!(parser.screen().contents(), "2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
     assert_eq!(parser.screen().cursor_position(), (14, 14));
 
     parser.process(b"\x1b[3S");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
+    assert_eq!(parser.screen().contents(), "5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
     assert_eq!(parser.screen().cursor_position(), (14, 14));
 
     parser.process(b"\x1b[T");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
+    assert_eq!(parser.screen().contents(), "\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
     assert_eq!(parser.screen().cursor_position(), (14, 14));
 
     parser.process(b"\x1b[5T");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "\n\n\n\n\n\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22");
+    assert_eq!(parser.screen().contents(), "\n\n\n\n\n\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22");
     assert_eq!(parser.screen().cursor_position(), (14, 14));
 }
diff --git a/tests/escape.rs b/tests/escape.rs
index 2c7d745..01ac574 100644
--- a/tests/escape.rs
+++ b/tests/escape.rs
@@ -14,7 +14,7 @@ fn deckpam() {
 fn ri() {
     let mut parser = vt100::Parser::new(24, 80);
     parser.process(b"foo\nbar\x1bMbaz");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "foo   baz\n   bar");
+    assert_eq!(parser.screen().contents(), "foo   baz\n   bar");
 }
 
 #[test]
@@ -25,8 +25,8 @@ fn ris() {
     let cell = parser.screen().cell(0, 0).unwrap();
     assert_eq!(cell.contents(), "");
 
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "");
-    assert_eq!(parser.screen().contents_formatted(0, 0, 23, 79), b"");
+    assert_eq!(parser.screen().contents(), "");
+    assert_eq!(parser.screen().contents_formatted(), b"");
 
     assert_eq!(parser.screen().title(), "");
     assert_eq!(parser.screen().icon_name(), "");
@@ -61,9 +61,9 @@ fn ris() {
     let cell = parser.screen().cell(0, 0).unwrap();
     assert_eq!(cell.contents(), "f");
 
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "foo");
+    assert_eq!(parser.screen().contents(), "foo");
     assert_eq!(
-        parser.screen().contents_formatted(0, 0, 23, 79),
+        parser.screen().contents_formatted(),
         b"f\x1b[31;47;1;3;4moo"
     );
 
@@ -99,8 +99,8 @@ fn ris() {
     let cell = parser.screen().cell(0, 0).unwrap();
     assert_eq!(cell.contents(), "");
 
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "");
-    assert_eq!(parser.screen().contents_formatted(0, 0, 23, 79), b"");
+    assert_eq!(parser.screen().contents(), "");
+    assert_eq!(parser.screen().contents_formatted(), b"");
 
     // title and icon name don't change with reset
     assert_eq!(parser.screen().title(), "window title");
@@ -145,14 +145,11 @@ fn vb() {
 fn decsc() {
     let mut parser = vt100::Parser::new(24, 80);
     parser.process(b"foo\x1b7\r\n\r\n\r\n         bar\x1b8baz");
-    assert_eq!(
-        parser.screen().contents(0, 0, 23, 79),
-        "foobaz\n\n\n         bar"
-    );
+    assert_eq!(parser.screen().contents(), "foobaz\n\n\n         bar");
     assert_eq!(parser.screen().cursor_position(), (0, 6));
 
     parser.process(b"\x1b[?47h\x1b[20;20H");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "");
+    assert_eq!(parser.screen().contents(), "");
     assert_eq!(parser.screen().cursor_position(), (19, 19));
 
     parser.process(b"\x1b8");
@@ -167,21 +164,21 @@ fn decsc() {
     parser.process(b"\x1bc\x1b[31m\x1b[5;15r\x1b[?6hfoo\x1b7");
     assert_eq!(parser.screen().cursor_position(), (4, 3));
     assert_eq!(
-        parser.screen().contents_formatted(0, 0, 23, 79),
+        parser.screen().contents_formatted(),
         b"\r\n\r\n\r\n\r\n\x1b[31mfoo"
     );
 
     parser.process(b"\x1b[32m\x1b[?6lbar");
     assert_eq!(parser.screen().cursor_position(), (0, 3));
     assert_eq!(
-        parser.screen().contents_formatted(0, 0, 23, 79),
+        parser.screen().contents_formatted(),
         b"\x1b[32mbar\r\n\r\n\r\n\r\n\x1b[31mfoo"
     );
 
     parser.process(b"\x1b8\x1b[Hz");
     assert_eq!(parser.screen().cursor_position(), (4, 1));
     assert_eq!(
-        parser.screen().contents_formatted(0, 0, 23, 79),
+        parser.screen().contents_formatted(),
         b"\x1b[32mbar\r\n\r\n\r\n\r\n\x1b[31mzoo"
     );
 }
diff --git a/tests/init.rs b/tests/init.rs
index 61395e4..9647765 100644
--- a/tests/init.rs
+++ b/tests/init.rs
@@ -15,8 +15,8 @@ fn init() {
     let cell = parser.screen().cell(0, 80);
     assert!(cell.is_none());
 
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "");
-    assert_eq!(parser.screen().contents_formatted(0, 0, 23, 79), b"");
+    assert_eq!(parser.screen().contents(), "");
+    assert_eq!(parser.screen().contents_formatted(), b"");
 
     assert_eq!(parser.screen().title(), "");
     assert_eq!(parser.screen().icon_name(), "");
diff --git a/tests/mode.rs b/tests/mode.rs
index 277cdad..dfc8490 100644
--- a/tests/mode.rs
+++ b/tests/mode.rs
@@ -324,74 +324,74 @@ fn alternate_buffer() {
     // 47
 
     parser.process(b"\x1bc");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "");
+    assert_eq!(parser.screen().contents(), "");
     assert_eq!(parser.screen().cursor_position(), (0, 0));
     assert!(!parser.screen().alternate_screen());
 
     parser.process(b"\x1b[m\x1b[2J\x1b[H1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
+    assert_eq!(parser.screen().contents(), "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
     assert_eq!(parser.screen().cursor_position(), (23, 2));
     assert!(!parser.screen().alternate_screen());
 
     parser.process(b"\x1b[?47h");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "");
+    assert_eq!(parser.screen().contents(), "");
     assert_eq!(parser.screen().cursor_position(), (0, 0));
     assert!(parser.screen().alternate_screen());
 
     parser.process(b"foobar");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "foobar");
+    assert_eq!(parser.screen().contents(), "foobar");
     assert_eq!(parser.screen().cursor_position(), (0, 6));
     assert!(parser.screen().alternate_screen());
 
     parser.process(b"\x1b[?47l");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
+    assert_eq!(parser.screen().contents(), "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
     assert_eq!(parser.screen().cursor_position(), (23, 2));
     assert!(!parser.screen().alternate_screen());
 
     parser.process(b"\x1b[?47h");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "foobar");
+    assert_eq!(parser.screen().contents(), "foobar");
     assert_eq!(parser.screen().cursor_position(), (0, 6));
     assert!(parser.screen().alternate_screen());
 
     parser.process(b"\x1b[?47l");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
+    assert_eq!(parser.screen().contents(), "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
     assert_eq!(parser.screen().cursor_position(), (23, 2));
     assert!(!parser.screen().alternate_screen());
 
     // 1049
 
     parser.process(b"\x1bc");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "");
+    assert_eq!(parser.screen().contents(), "");
     assert_eq!(parser.screen().cursor_position(), (0, 0));
     assert!(!parser.screen().alternate_screen());
 
     parser.process(b"\x1b[m\x1b[2J\x1b[H1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
+    assert_eq!(parser.screen().contents(), "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
     assert_eq!(parser.screen().cursor_position(), (23, 2));
     assert!(!parser.screen().alternate_screen());
 
     parser.process(b"\x1b[?1049h");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "");
+    assert_eq!(parser.screen().contents(), "");
     assert_eq!(parser.screen().cursor_position(), (0, 0));
     assert!(parser.screen().alternate_screen());
 
     parser.process(b"foobar");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "foobar");
+    assert_eq!(parser.screen().contents(), "foobar");
     assert_eq!(parser.screen().cursor_position(), (0, 6));
     assert!(parser.screen().alternate_screen());
 
     parser.process(b"\x1b[?1049l");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
+    assert_eq!(parser.screen().contents(), "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
     assert_eq!(parser.screen().cursor_position(), (23, 2));
     assert!(!parser.screen().alternate_screen());
 
     parser.process(b"\x1b[?1049h");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "");
+    assert_eq!(parser.screen().contents(), "");
     assert_eq!(parser.screen().cursor_position(), (0, 0));
     assert!(parser.screen().alternate_screen());
 
     parser.process(b"\x1b[?1049l");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
+    assert_eq!(parser.screen().contents(), "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
     assert_eq!(parser.screen().cursor_position(), (23, 2));
     assert!(!parser.screen().alternate_screen());
 }
diff --git a/tests/processing.rs b/tests/processing.rs
index 282ab65..4fdb8cb 100644
--- a/tests/processing.rs
+++ b/tests/processing.rs
@@ -3,41 +3,41 @@
 #[test]
 fn split_escape_sequences() {
     let mut parser = vt100::Parser::new(24, 80);
-    let contents = parser.screen().contents(0, 0, 23, 79);
+    let contents = parser.screen().contents();
     parser.process(b"abc");
-    assert_ne!(parser.screen().contents(0, 0, 23, 79), contents);
-    let contents = parser.screen().contents(0, 0, 23, 79);
+    assert_ne!(parser.screen().contents(), contents);
+    let contents = parser.screen().contents();
     parser.process(b"abc\x1b[12;24Hdef");
-    assert_ne!(parser.screen().contents(0, 0, 23, 79), contents);
-    let contents = parser.screen().contents(0, 0, 23, 79);
+    assert_ne!(parser.screen().contents(), contents);
+    let contents = parser.screen().contents();
     assert!(contents.contains("abc"));
     assert!(contents.contains("def"));
     assert_eq!(parser.screen().cursor_position(), (11, 26));
 
     parser.process(b"\x1b");
     assert_eq!(parser.screen().cursor_position(), (11, 26));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"[");
     assert_eq!(parser.screen().cursor_position(), (11, 26));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"1");
     assert_eq!(parser.screen().cursor_position(), (11, 26));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"2");
     assert_eq!(parser.screen().cursor_position(), (11, 26));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b";");
     assert_eq!(parser.screen().cursor_position(), (11, 26));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"2");
     assert_eq!(parser.screen().cursor_position(), (11, 26));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"4");
     assert_eq!(parser.screen().cursor_position(), (11, 26));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"H");
     assert_eq!(parser.screen().cursor_position(), (11, 23));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
 
     assert_eq!(
         parser.screen().mouse_protocol_mode(),
@@ -49,56 +49,56 @@ fn split_escape_sequences() {
         vt100::MouseProtocolMode::None
     );
     assert_eq!(parser.screen().cursor_position(), (11, 23));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"[");
     assert_eq!(
         parser.screen().mouse_protocol_mode(),
         vt100::MouseProtocolMode::None
     );
     assert_eq!(parser.screen().cursor_position(), (11, 23));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"?");
     assert_eq!(
         parser.screen().mouse_protocol_mode(),
         vt100::MouseProtocolMode::None
     );
     assert_eq!(parser.screen().cursor_position(), (11, 23));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"1");
     assert_eq!(
         parser.screen().mouse_protocol_mode(),
         vt100::MouseProtocolMode::None
     );
     assert_eq!(parser.screen().cursor_position(), (11, 23));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"0");
     assert_eq!(
         parser.screen().mouse_protocol_mode(),
         vt100::MouseProtocolMode::None
     );
     assert_eq!(parser.screen().cursor_position(), (11, 23));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"0");
     assert_eq!(
         parser.screen().mouse_protocol_mode(),
         vt100::MouseProtocolMode::None
     );
     assert_eq!(parser.screen().cursor_position(), (11, 23));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"0");
     assert_eq!(
         parser.screen().mouse_protocol_mode(),
         vt100::MouseProtocolMode::None
     );
     assert_eq!(parser.screen().cursor_position(), (11, 23));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"h");
     assert_eq!(
         parser.screen().mouse_protocol_mode(),
         vt100::MouseProtocolMode::PressRelease
     );
     assert_eq!(parser.screen().cursor_position(), (11, 23));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
 
     assert_eq!(parser.screen().title(), "");
     parser.process(b"\x1b");
@@ -108,7 +108,7 @@ fn split_escape_sequences() {
         vt100::MouseProtocolMode::PressRelease
     );
     assert_eq!(parser.screen().cursor_position(), (11, 23));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"]");
     assert_eq!(parser.screen().title(), "");
     assert_eq!(
@@ -116,7 +116,7 @@ fn split_escape_sequences() {
         vt100::MouseProtocolMode::PressRelease
     );
     assert_eq!(parser.screen().cursor_position(), (11, 23));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"0");
     assert_eq!(parser.screen().title(), "");
     assert_eq!(
@@ -124,7 +124,7 @@ fn split_escape_sequences() {
         vt100::MouseProtocolMode::PressRelease
     );
     assert_eq!(parser.screen().cursor_position(), (11, 23));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b";");
     assert_eq!(parser.screen().title(), "");
     assert_eq!(
@@ -132,7 +132,7 @@ fn split_escape_sequences() {
         vt100::MouseProtocolMode::PressRelease
     );
     assert_eq!(parser.screen().cursor_position(), (11, 23));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"a");
     assert_eq!(parser.screen().title(), "");
     assert_eq!(
@@ -140,7 +140,7 @@ fn split_escape_sequences() {
         vt100::MouseProtocolMode::PressRelease
     );
     assert_eq!(parser.screen().cursor_position(), (11, 23));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b" ");
     assert_eq!(parser.screen().title(), "");
     assert_eq!(
@@ -148,7 +148,7 @@ fn split_escape_sequences() {
         vt100::MouseProtocolMode::PressRelease
     );
     assert_eq!(parser.screen().cursor_position(), (11, 23));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"'");
     assert_eq!(parser.screen().title(), "");
     assert_eq!(
@@ -156,7 +156,7 @@ fn split_escape_sequences() {
         vt100::MouseProtocolMode::PressRelease
     );
     assert_eq!(parser.screen().cursor_position(), (11, 23));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"[");
     assert_eq!(parser.screen().title(), "");
     assert_eq!(
@@ -164,7 +164,7 @@ fn split_escape_sequences() {
         vt100::MouseProtocolMode::PressRelease
     );
     assert_eq!(parser.screen().cursor_position(), (11, 23));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"]");
     assert_eq!(parser.screen().title(), "");
     assert_eq!(
@@ -172,7 +172,7 @@ fn split_escape_sequences() {
         vt100::MouseProtocolMode::PressRelease
     );
     assert_eq!(parser.screen().cursor_position(), (11, 23));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"_");
     assert_eq!(parser.screen().title(), "");
     assert_eq!(
@@ -180,7 +180,7 @@ fn split_escape_sequences() {
         vt100::MouseProtocolMode::PressRelease
     );
     assert_eq!(parser.screen().cursor_position(), (11, 23));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"\x07");
     assert_eq!(parser.screen().title(), "a '[]_");
     assert_eq!(
@@ -188,37 +188,37 @@ fn split_escape_sequences() {
         vt100::MouseProtocolMode::PressRelease
     );
     assert_eq!(parser.screen().cursor_position(), (11, 23));
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
 }
 
 #[test]
 fn split_utf8() {
     let mut parser = vt100::Parser::new(24, 80);
-    let contents = parser.screen().contents(0, 0, 23, 79);
+    let contents = parser.screen().contents();
     parser.process(b"a");
-    assert_ne!(parser.screen().contents(0, 0, 23, 79), contents);
-    let contents = parser.screen().contents(0, 0, 23, 79);
+    assert_ne!(parser.screen().contents(), contents);
+    let contents = parser.screen().contents();
 
     parser.process(b"\xc3");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"\xa1");
-    assert_ne!(parser.screen().contents(0, 0, 23, 79), contents);
-    let contents = parser.screen().contents(0, 0, 23, 79);
+    assert_ne!(parser.screen().contents(), contents);
+    let contents = parser.screen().contents();
 
     parser.process(b"\xe3");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"\x82");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"\xad");
-    assert_ne!(parser.screen().contents(0, 0, 23, 79), contents);
-    let contents = parser.screen().contents(0, 0, 23, 79);
+    assert_ne!(parser.screen().contents(), contents);
+    let contents = parser.screen().contents();
 
     parser.process(b"\xf0");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"\x9f");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"\x92");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_eq!(parser.screen().contents(), contents);
     parser.process(b"\xa9");
-    assert_ne!(parser.screen().contents(0, 0, 23, 79), contents);
+    assert_ne!(parser.screen().contents(), contents);
 }
diff --git a/tests/scroll.rs b/tests/scroll.rs
index a8bfb05..b7f3df9 100644
--- a/tests/scroll.rs
+++ b/tests/scroll.rs
@@ -2,10 +2,10 @@
 fn scroll_regions() {
     let mut parser = vt100::Parser::new(24, 80);
     parser.process(b"\x1b[m\x1b[2J\x1b[H1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
+    assert_eq!(parser.screen().contents(), "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
 
     parser.process(b"\x1b[24;50H\n");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
+    assert_eq!(parser.screen().contents(), "2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
 
     parser.process(b"\x1b[m\x1b[2J\x1b[H1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24");
 
@@ -16,7 +16,7 @@ fn scroll_regions() {
     assert_eq!(parser.screen().cursor_position(), (19, 49));
 
     parser.process(b"\n");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "1\n2\n3\n4\n5\n6\n7\n8\n9\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n\n21\n22\n23\n24");
+    assert_eq!(parser.screen().contents(), "1\n2\n3\n4\n5\n6\n7\n8\n9\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n\n21\n22\n23\n24");
     assert_eq!(parser.screen().cursor_position(), (19, 49));
 
     parser.process(b"\x1b[B");
@@ -26,9 +26,9 @@ fn scroll_regions() {
     assert_eq!(parser.screen().cursor_position(), (9, 49));
     parser.process(b"\x1b[1;24r\x1b[m\x1b[2J\x1b[H1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24");
     parser.process(b"\x1b[10;20r\x1b[15;50H\x1b[2L");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n\n\n15\n16\n17\n18\n21\n22\n23\n24");
+    assert_eq!(parser.screen().contents(), "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n\n\n15\n16\n17\n18\n21\n22\n23\n24");
     parser.process(b"\x1b[10;50H\x1bM");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "1\n2\n3\n4\n5\n6\n7\n8\n9\n\n10\n11\n12\n13\n14\n\n\n15\n16\n17\n21\n22\n23\n24");
+    assert_eq!(parser.screen().contents(), "1\n2\n3\n4\n5\n6\n7\n8\n9\n\n10\n11\n12\n13\n14\n\n\n15\n16\n17\n21\n22\n23\n24");
 }
 
 #[test]
diff --git a/tests/split-escapes.rs b/tests/split-escapes.rs
index 157ff29..6339c07 100644
--- a/tests/split-escapes.rs
+++ b/tests/split-escapes.rs
@@ -13,8 +13,8 @@ fn write_to_parser(chunks: &mut Vec<Vec<u8>>) -> (String, Vec<u8>) {
         parser.process(&chunk);
     }
     (
-        parser.screen().contents(0, 0, 36, 192),
-        parser.screen().contents_formatted(0, 0, 36, 192),
+        parser.screen().contents(),
+        parser.screen().contents_formatted(),
     )
 }
 
diff --git a/tests/text.rs b/tests/text.rs
index b3f3520..7206e63 100644
--- a/tests/text.rs
+++ b/tests/text.rs
@@ -9,8 +9,8 @@ fn ascii() {
     assert_eq!(parser.screen().cell(0, 2).unwrap().contents(), "o");
     assert_eq!(parser.screen().cell(0, 3).unwrap().contents(), "");
     assert_eq!(parser.screen().cell(1, 0).unwrap().contents(), "");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "foo");
-    assert_eq!(parser.screen().contents(0, 0, 500, 500), "foo");
+    assert_eq!(parser.screen().contents(), "foo");
+    assert_eq!(parser.screen().contents(), "foo");
 }
 
 #[test]
@@ -23,8 +23,8 @@ fn utf8() {
     assert_eq!(parser.screen().cell(0, 3).unwrap().contents(), "é");
     assert_eq!(parser.screen().cell(0, 4).unwrap().contents(), "");
     assert_eq!(parser.screen().cell(1, 0).unwrap().contents(), "");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "café");
-    assert_eq!(parser.screen().contents(0, 0, 500, 500), "café");
+    assert_eq!(parser.screen().contents(), "café");
+    assert_eq!(parser.screen().contents(), "café");
 }
 
 #[test]
@@ -42,8 +42,8 @@ fn newlines() {
     assert_eq!(parser.screen().cell(2, 2).unwrap().contents(), "d");
     assert_eq!(parser.screen().cell(0, 3).unwrap().contents(), "");
     assert_eq!(parser.screen().cell(3, 0).unwrap().contents(), "");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "f\noo\nood");
-    assert_eq!(parser.screen().contents(0, 0, 500, 500), "f\noo\nood");
+    assert_eq!(parser.screen().contents(), "f\noo\nood");
+    assert_eq!(parser.screen().contents(), "f\noo\nood");
 }
 
 #[test]
@@ -58,8 +58,8 @@ fn wide() {
     assert_eq!(parser.screen().cell(0, 5).unwrap().contents(), "");
     assert_eq!(parser.screen().cell(0, 6).unwrap().contents(), "");
     assert_eq!(parser.screen().cell(1, 0).unwrap().contents(), "");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "aデbネ");
-    assert_eq!(parser.screen().contents(0, 0, 500, 500), "aデbネ");
+    assert_eq!(parser.screen().contents(), "aデbネ");
+    assert_eq!(parser.screen().contents(), "aデbネ");
 }
 
 #[test]
@@ -69,10 +69,10 @@ fn combining() {
     assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "a");
     parser.process("\u{0301}".as_bytes());
     assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "á");
-    parser.process(b"\x1b[20;20Habcdefg");
-    assert_eq!(parser.screen().contents(19, 19, 19, 26), "abcdefg");
-    parser.process("\x1b[20;25H\u{0301}".as_bytes());
-    assert_eq!(parser.screen().contents(19, 19, 19, 26), "abcdéfg");
+    parser.process(b"\x1bcabcdefg");
+    assert_eq!(parser.screen().contents(), "abcdefg");
+    parser.process("\x1b[1;6H\u{0301}".as_bytes());
+    assert_eq!(parser.screen().contents(), "abcdéfg");
     parser.process(b"\x1b[10;78Haaa");
     assert_eq!(parser.screen().cell(9, 79).unwrap().contents(), "a");
     parser.process("\r\n\u{0301}".as_bytes());
@@ -84,34 +84,34 @@ fn combining() {
 fn wrap() {
     let mut parser = vt100::Parser::new(24, 80);
     parser.process(b"0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789");
+    assert_eq!(parser.screen().contents(), "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789");
     parser.process(b"\x1b[5H01234567890123456789012345678901234567890123456789012345678901234567890123456789");
     parser.process(b"\x1b[6H01234567890123456789012345678901234567890123456789012345678901234567890123456789");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789\n\n\n01234567890123456789012345678901234567890123456789012345678901234567890123456789\n01234567890123456789012345678901234567890123456789012345678901234567890123456789");
+    assert_eq!(parser.screen().contents(), "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789\n\n\n01234567890123456789012345678901234567890123456789012345678901234567890123456789\n01234567890123456789012345678901234567890123456789012345678901234567890123456789");
 
     parser.process(b"\x1b[H\x1b[J");
     parser.process(b"0123456789012345678901234567890123456789012345678901234567890123456789012345678");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "0123456789012345678901234567890123456789012345678901234567890123456789012345678");
+    assert_eq!(parser.screen().contents(), "0123456789012345678901234567890123456789012345678901234567890123456789012345678");
     assert_eq!(parser.screen().cursor_position(), (0, 79));
     parser.process(b"9");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "01234567890123456789012345678901234567890123456789012345678901234567890123456789");
+    assert_eq!(parser.screen().contents(), "01234567890123456789012345678901234567890123456789012345678901234567890123456789");
     assert_eq!(parser.screen().cursor_position(), (0, 80));
     parser.process(b"a");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "01234567890123456789012345678901234567890123456789012345678901234567890123456789a");
+    assert_eq!(parser.screen().contents(), "01234567890123456789012345678901234567890123456789012345678901234567890123456789a");
     assert_eq!(parser.screen().cursor_position(), (1, 1));
     parser.process(b"b");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "01234567890123456789012345678901234567890123456789012345678901234567890123456789ab");
+    assert_eq!(parser.screen().contents(), "01234567890123456789012345678901234567890123456789012345678901234567890123456789ab");
     assert_eq!(parser.screen().cursor_position(), (1, 2));
 
     parser.process(b"\x1b[H\x1b[J");
     parser.process(b"012345678901234567890123456789012345678901234567890123456789012345678901234567");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "012345678901234567890123456789012345678901234567890123456789012345678901234567");
+    assert_eq!(parser.screen().contents(), "012345678901234567890123456789012345678901234567890123456789012345678901234567");
     assert_eq!(parser.screen().cursor_position(), (0, 78));
     parser.process("ネ".as_bytes());
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "012345678901234567890123456789012345678901234567890123456789012345678901234567ネ");
+    assert_eq!(parser.screen().contents(), "012345678901234567890123456789012345678901234567890123456789012345678901234567ネ");
     assert_eq!(parser.screen().cursor_position(), (0, 80));
     parser.process(b"a");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "012345678901234567890123456789012345678901234567890123456789012345678901234567ネa");
+    assert_eq!(parser.screen().contents(), "012345678901234567890123456789012345678901234567890123456789012345678901234567ネa");
     assert_eq!(parser.screen().cursor_position(), (1, 1));
     assert_eq!(parser.screen().cell(0, 77).unwrap().contents(), "7");
     assert_eq!(parser.screen().cell(0, 78).unwrap().contents(), "ネ");
@@ -121,13 +121,13 @@ fn wrap() {
 
     parser.process(b"\x1b[H\x1b[J");
     parser.process(b"0123456789012345678901234567890123456789012345678901234567890123456789012345678");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "0123456789012345678901234567890123456789012345678901234567890123456789012345678");
+    assert_eq!(parser.screen().contents(), "0123456789012345678901234567890123456789012345678901234567890123456789012345678");
     assert_eq!(parser.screen().cursor_position(), (0, 79));
     parser.process("ネ".as_bytes());
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "0123456789012345678901234567890123456789012345678901234567890123456789012345678ネ");
+    assert_eq!(parser.screen().contents(), "0123456789012345678901234567890123456789012345678901234567890123456789012345678ネ");
     assert_eq!(parser.screen().cursor_position(), (1, 2));
     parser.process(b"a");
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "0123456789012345678901234567890123456789012345678901234567890123456789012345678ネa");
+    assert_eq!(parser.screen().contents(), "0123456789012345678901234567890123456789012345678901234567890123456789012345678ネa");
     assert_eq!(parser.screen().cursor_position(), (1, 3));
     assert_eq!(parser.screen().cell(0, 77).unwrap().contents(), "7");
     assert_eq!(parser.screen().cell(0, 78).unwrap().contents(), "8");
@@ -142,7 +142,7 @@ fn wrap() {
 fn soft_hyphen() {
     let mut parser = vt100::Parser::new(24, 140);
     parser.process(b"Free En\xc2\xadter\xc2\xadprise is gonna ru\xc2\xadin ev\xc2\xadery\xc2\xadthing good un\xc2\xadless we take a knife to its tes\xc2\xadti\xc2\xadcles first.");
-    assert_eq!(parser.screen().contents(0, 0, 0, 139), "Free En\u{00ad}ter\u{00ad}prise is gonna ru\u{00ad}in ev\u{00ad}ery\u{00ad}thing good un\u{00ad}less we take a knife to its tes\u{00ad}ti\u{00ad}cles first.");
+    assert_eq!(parser.screen().contents(), "Free En\u{00ad}ter\u{00ad}prise is gonna ru\u{00ad}in ev\u{00ad}ery\u{00ad}thing good un\u{00ad}less we take a knife to its tes\u{00ad}ti\u{00ad}cles first.");
     assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "F");
     assert_eq!(parser.screen().cell(0, 1).unwrap().contents(), "r");
     assert_eq!(parser.screen().cell(0, 2).unwrap().contents(), "e");
diff --git a/tests/window_contents.rs b/tests/window_contents.rs
index d79f75a..ccf5342 100644
--- a/tests/window_contents.rs
+++ b/tests/window_contents.rs
@@ -2,7 +2,7 @@
 fn formatted() {
     let mut parser = vt100::Parser::new(24, 80);
     compare_formatted(&parser);
-    assert_eq!(parser.screen().contents_formatted(0, 0, 23, 79), b"");
+    assert_eq!(parser.screen().contents_formatted(), b"");
 
     parser.process(b"foobar");
     compare_formatted(&parser);
@@ -10,7 +10,7 @@ fn formatted() {
     assert!(!parser.screen().cell(0, 3).unwrap().bold());
     assert!(!parser.screen().cell(0, 4).unwrap().bold());
     assert!(!parser.screen().cell(0, 5).unwrap().bold());
-    assert_eq!(parser.screen().contents_formatted(0, 0, 23, 79), b"foobar");
+    assert_eq!(parser.screen().contents_formatted(), b"foobar");
 
     parser.process(b"\x1b[1;4H\x1b[1;7m\x1b[33mb");
     compare_formatted(&parser);
@@ -19,7 +19,7 @@ fn formatted() {
     assert!(!parser.screen().cell(0, 4).unwrap().bold());
     assert!(!parser.screen().cell(0, 5).unwrap().bold());
     assert_eq!(
-        parser.screen().contents_formatted(0, 0, 23, 79),
+        parser.screen().contents_formatted(),
         b"foo\x1b[33;1;7mb\x1b[mar"
     );
 
@@ -30,28 +30,28 @@ fn formatted() {
     assert!(!parser.screen().cell(0, 4).unwrap().bold());
     assert!(!parser.screen().cell(0, 5).unwrap().bold());
     assert_eq!(
-        parser.screen().contents_formatted(0, 0, 23, 79),
+        parser.screen().contents_formatted(),
         b"foo\x1b[33;1;7mb\x1b[42;22ma\x1b[mr"
     );
 
     parser.process(b"\x1b[1;6H\x1b[35mr\r\nquux");
     compare_formatted(&parser);
     assert_eq!(
-        parser.screen().contents_formatted(0, 0, 23, 79),
+        parser.screen().contents_formatted(),
         &b"foo\x1b[33;1;7mb\x1b[42;22ma\x1b[35mr\r\nquux"[..]
     );
 
     parser.process(b"\x1b[2;1H\x1b[45mquux");
     compare_formatted(&parser);
     assert_eq!(
-        parser.screen().contents_formatted(0, 0, 23, 79),
+        parser.screen().contents_formatted(),
         &b"foo\x1b[33;1;7mb\x1b[42;22ma\x1b[35mr\r\n\x1b[45mquux"[..]
     );
 
     parser
         .process(b"\x1b[2;2H\x1b[38;2;123;213;231mu\x1b[38;5;254mu\x1b[39mx");
     compare_formatted(&parser);
-    assert_eq!(parser.screen().contents_formatted(0, 0 ,23, 79), &b"foo\x1b[33;1;7mb\x1b[42;22ma\x1b[35mr\r\n\x1b[45mq\x1b[38;2;123;213;231mu\x1b[38;5;254mu\x1b[39mx"[..]);
+    assert_eq!(parser.screen().contents_formatted(), &b"foo\x1b[33;1;7mb\x1b[42;22ma\x1b[35mr\r\n\x1b[45mq\x1b[38;2;123;213;231mu\x1b[38;5;254mu\x1b[39mx"[..]);
 }
 
 #[test]
@@ -59,17 +59,268 @@ fn empty_cells() {
     let mut parser = vt100::Parser::new(24, 80);
     parser.process(b"\x1b[5C\x1b[32m bar\x1b[H\x1b[31mfoo");
     compare_formatted(&parser);
-    assert_eq!(parser.screen().contents(0, 0, 23, 79), "foo   bar");
+    assert_eq!(parser.screen().contents(), "foo   bar");
     assert_eq!(
-        parser.screen().contents_formatted(0, 0, 23, 79),
+        parser.screen().contents_formatted(),
         b"\x1b[31mfoo\x1b[m\x1b[C\x1b[C\x1b[32m bar"
     );
 }
 
+#[test]
+fn rows() {
+    let mut parser = vt100::Parser::new(24, 80);
+    assert_eq!(
+        parser.screen().rows(0, 80).collect::<Vec<String>>(),
+        vec![
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+        ]
+    );
+    assert_eq!(
+        parser
+            .screen()
+            .rows_formatted(0, 80)
+            .collect::<Vec<Vec<u8>>>(),
+        vec![
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+        ]
+    );
+    assert_eq!(
+        parser.screen().rows(5, 15).collect::<Vec<String>>(),
+        vec![
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+        ]
+    );
+    assert_eq!(
+        parser
+            .screen()
+            .rows_formatted(5, 15)
+            .collect::<Vec<Vec<u8>>>(),
+        vec![
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+        ]
+    );
+
+    parser
+        .process(b"\x1b[31mfoo\x1b[10;10H\x1b[32mbar\x1b[20;20H\x1b[33mbaz");
+    assert_eq!(
+        parser.screen().rows(0, 80).collect::<Vec<String>>(),
+        vec![
+            "foo".to_string(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            "         bar".to_string(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            "                   baz".to_string(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+        ]
+    );
+    assert_eq!(
+        parser
+            .screen()
+            .rows_formatted(0, 80)
+            .collect::<Vec<Vec<u8>>>(),
+        vec![
+            b"\x1b[31mfoo".to_vec(),
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            b"\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[32mbar".to_vec(),
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            b"\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[33mbaz".to_vec(),
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+        ]
+    );
+    assert_eq!(
+        parser.screen().rows(5, 15).collect::<Vec<String>>(),
+        vec![
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            "    bar".to_string(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+            "              b".to_string(),
+            String::new(),
+            String::new(),
+            String::new(),
+            String::new(),
+        ]
+    );
+    assert_eq!(
+        parser
+            .screen()
+            .rows_formatted(5, 15)
+            .collect::<Vec<Vec<u8>>>(),
+        vec![
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            b"\x1b[C\x1b[C\x1b[C\x1b[C\x1b[32mbar".to_vec(),
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+            b"\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[C\x1b[33mb".to_vec(),
+            vec![],
+            vec![],
+            vec![],
+            vec![],
+        ]
+    );
+}
+
 fn compare_formatted(parser: &vt100::Parser) {
     let (rows, cols) = parser.screen().size();
-    let contents =
-        parser.screen().contents_formatted(0, 0, rows - 1, cols - 1);
+    let contents = parser.screen().contents_formatted();
     let mut parser2 = vt100::Parser::new(rows, cols);
     parser2.process(&contents);
     compare_cells(parser, &parser2);