From 2e7f1686d719497d9b2d2d2c8ffba20e6c8214bd Mon Sep 17 00:00:00 2001
From: Jesse Luehrs <doy@tozt.net>
Date: Tue, 5 Nov 2019 12:53:25 -0500
Subject: 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.
---
 tests/basic.rs           |  17 +--
 tests/control.rs         |  10 +-
 tests/csi.rs             | 128 ++++++++++------------
 tests/escape.rs          |  27 +++--
 tests/init.rs            |   4 +-
 tests/mode.rs            |  28 ++---
 tests/processing.rs      |  92 ++++++++--------
 tests/scroll.rs          |  10 +-
 tests/split-escapes.rs   |   4 +-
 tests/text.rs            |  50 ++++-----
 tests/window_contents.rs | 273 +++++++++++++++++++++++++++++++++++++++++++++--
 11 files changed, 435 insertions(+), 208 deletions(-)

(limited to 'tests')

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);
-- 
cgit v1.2.3-54-g00ecf