optionally save scrollback rows

20 files changed, 89 insertions, 67 deletions

diff --git a/examples/process.rs b/examples/process.rs
index ea36db1..a556b96 100644
--- a/examples/process.rs
+++ b/examples/process.rs
@@ -12,7 +12,7 @@ fn read_frames() -> impl Iterator<Item = Vec<u8>> {
 }
 
 fn process_frames(frames: &[Vec<u8>]) {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     for frame in frames {
         parser.process(&frame);
     }
diff --git a/examples/process_diff.rs b/examples/process_diff.rs
index 6132971..d618d9c 100644
--- a/examples/process_diff.rs
+++ b/examples/process_diff.rs
@@ -13,7 +13,7 @@ fn read_frames() -> impl Iterator<Item = Vec<u8>> {
 
 fn draw_frames(frames: &[Vec<u8>]) {
     let mut stdout = std::io::stdout();
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     let mut screen = parser.screen().clone();
     for frame in frames {
         parser.process(&frame);
diff --git a/examples/process_full.rs b/examples/process_full.rs
index a49af29..2260443 100644
--- a/examples/process_full.rs
+++ b/examples/process_full.rs
@@ -13,7 +13,7 @@ fn read_frames() -> impl Iterator<Item = Vec<u8>> {
 
 fn draw_frames(frames: &[Vec<u8>]) {
     let mut stdout = std::io::stdout();
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     for frame in frames {
         parser.process(&frame);
         let contents = parser.screen().contents_formatted();
diff --git a/src/grid.rs b/src/grid.rs
index 287e5e4..5a53c6e 100644
--- a/src/grid.rs
+++ b/src/grid.rs
@@ -12,10 +12,12 @@ pub struct Grid {
     scroll_bottom: u16,
     origin_mode: bool,
     saved_origin_mode: bool,
+    scrollback: std::collections::VecDeque<(usize, crate::row::Row)>,
+    scrollback_len: usize,
 }
 
 impl Grid {
-    pub fn new(size: Size) -> Self {
+    pub fn new(size: Size, scrollback_len: usize) -> Self {
         Self {
             size,
             pos: Pos::default(),
@@ -25,6 +27,8 @@ impl Grid {
             scroll_bottom: size.rows - 1,
             origin_mode: false,
             saved_origin_mode: false,
+            scrollback: std::collections::VecDeque::new(),
+            scrollback_len,
         }
     }
 
@@ -127,6 +131,10 @@ impl Grid {
             .expect("cursor not pointing to a cell")
     }
 
+    pub fn scrollback_len(&self) -> usize {
+        self.scrollback_len
+    }
+
     pub fn write_contents(&self, contents: &mut String) {
         for row in self.rows() {
             row.write_contents(contents, 0, self.size.cols);
@@ -309,7 +317,14 @@ impl Grid {
         for _ in 0..(count.min(self.size.rows - self.scroll_top)) {
             self.rows
                 .insert(self.scroll_bottom as usize + 1, self.new_row());
-            self.rows.remove(self.scroll_top as usize);
+            let removed = self.rows.remove(self.scroll_top as usize);
+            if self.scrollback_len > 0 && !self.scroll_region_active() {
+                let idx = self.scrollback.back().map_or(0, |r| r.0 + 1);
+                self.scrollback.push_back((idx, removed));
+                while self.scrollback.len() > self.scrollback_len {
+                    self.scrollback.pop_front();
+                }
+            }
         }
     }
 
@@ -337,6 +352,10 @@ impl Grid {
         self.pos.row >= self.scroll_top && self.pos.row <= self.scroll_bottom
     }
 
+    fn scroll_region_active(&self) -> bool {
+        self.scroll_top != 0 || self.scroll_bottom != self.size.rows - 1
+    }
+
     pub fn set_origin_mode(&mut self, mode: bool) {
         self.origin_mode = mode;
         self.set_pos(Pos { row: 0, col: 0 })
diff --git a/src/parser.rs b/src/parser.rs
index 77373bd..0cabb1a 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -7,13 +7,13 @@ pub struct Parser {
 
 impl Parser {
     /// Creates a new terminal parser of the given size.
-    pub fn new(rows: u16, cols: u16) -> Self {
+    pub fn new(rows: u16, cols: u16, scrollback_len: usize) -> Self {
         Self {
             parser: vte::Parser::new(),
-            screen: crate::screen::Screen::new(crate::grid::Size {
-                rows,
-                cols,
-            }),
+            screen: crate::screen::Screen::new(
+                crate::grid::Size { rows, cols },
+                scrollback_len,
+            ),
         }
     }
 
diff --git a/src/screen.rs b/src/screen.rs
index 05b8935..f3fdf6a 100644
--- a/src/screen.rs
+++ b/src/screen.rs
@@ -91,10 +91,13 @@ pub struct Screen {
 }
 
 impl Screen {
-    pub(crate) fn new(size: crate::grid::Size) -> Self {
+    pub(crate) fn new(
+        size: crate::grid::Size,
+        scrollback_len: usize,
+    ) -> Self {
         Self {
-            grid: crate::grid::Grid::new(size),
-            alternate_grid: crate::grid::Grid::new(size),
+            grid: crate::grid::Grid::new(size, scrollback_len),
+            alternate_grid: crate::grid::Grid::new(size, 0),
 
             attrs: crate::attrs::Attrs::default(),
             saved_attrs: crate::attrs::Attrs::default(),
@@ -551,7 +554,7 @@ impl Screen {
         let title = self.title.clone();
         let icon_name = self.icon_name.clone();
 
-        *self = Self::new(self.grid().size());
+        *self = Self::new(self.grid.size(), self.grid.scrollback_len());
 
         self.outputs = outputs;
         self.title = title;
diff --git a/tests/attr.rs b/tests/attr.rs
index 1446bc5..3d33b07 100644
--- a/tests/attr.rs
+++ b/tests/attr.rs
@@ -2,7 +2,7 @@
 
 #[test]
 fn colors() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
 
     parser.process(b"foo\x1b[31mbar");
 
@@ -175,7 +175,7 @@ fn colors() {
 
 #[test]
 fn attrs() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
 
     parser.process(b"f\x1b[1mo\x1b[3mo\x1b[4mo\x1b[7mo");
     assert!(!parser.screen().cell(0, 0).unwrap().bold());
diff --git a/tests/basic.rs b/tests/basic.rs
index 1d30ddf..0e6fee0 100644
--- a/tests/basic.rs
+++ b/tests/basic.rs
@@ -1,12 +1,12 @@
 #[test]
 fn object_creation() {
-    let parser = vt100::Parser::new(24, 80);
+    let parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().size(), (24, 80));
 }
 
 #[test]
 fn process_text() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     let input = b"foo\x1b[31m\x1b[32mb\x1b[3;7;42ma\x1b[23mr";
     parser.process(input);
     assert_eq!(parser.screen().contents(), "foobar");
@@ -14,7 +14,7 @@ fn process_text() {
 
 #[test]
 fn set_size() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().size(), (24, 80));
     assert_eq!(parser.screen().cursor_position(), (0, 0));
 
@@ -58,7 +58,7 @@ fn set_size() {
 
 #[test]
 fn cell_contents() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     let input = b"foo\x1b[31m\x1b[32mb\x1b[3;7;42ma\x1b[23mr";
     parser.process(input);
     assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "f");
@@ -72,7 +72,7 @@ fn cell_contents() {
 
 #[test]
 fn cell_colors() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     let input = b"foo\x1b[31m\x1b[32mb\x1b[3;7;42ma\x1b[23mr";
     parser.process(input);
 
@@ -96,7 +96,7 @@ fn cell_colors() {
 
 #[test]
 fn cell_attrs() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     let input = b"foo\x1b[31m\x1b[32mb\x1b[3;7;42ma\x1b[23mr";
     parser.process(input);
 
diff --git a/tests/control.rs b/tests/control.rs
index 6f9c5b4..5b97581 100644
--- a/tests/control.rs
+++ b/tests/control.rs
@@ -1,6 +1,6 @@
 #[test]
 fn bel() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
 
     assert!(!parser.screen_mut().check_audible_bell());
 
@@ -11,7 +11,7 @@ fn bel() {
 
 #[test]
 fn bs() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
 
     parser.process(b"foo\x08\x08aa");
     assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "f");
@@ -33,7 +33,7 @@ fn bs() {
 
 #[test]
 fn tab() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
 
     parser.process(b"foo\tbar");
     assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "f");
@@ -52,7 +52,7 @@ fn tab() {
 }
 
 fn lf_with(b: u8) {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
 
     parser.process(b"foo");
     parser.process(&[b]);
@@ -88,7 +88,7 @@ fn ff() {
 
 #[test]
 fn cr() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
 
     parser.process(b"fooo\rbar");
     assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "b");
diff --git a/tests/csi.rs b/tests/csi.rs
index e5e19cd..1c1ed46 100644
--- a/tests/csi.rs
+++ b/tests/csi.rs
@@ -1,6 +1,6 @@
 #[test]
 fn absolute_movement() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().cursor_position(), (0, 0));
 
     parser.process(b"\x1b[10;10H");
@@ -36,7 +36,7 @@ fn absolute_movement() {
 
 #[test]
 fn relative_movement() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().cursor_position(), (0, 0));
 
     parser.process(b"\x1b[C");
@@ -91,7 +91,7 @@ fn relative_movement() {
 #[allow(clippy::cognitive_complexity)]
 #[test]
 fn ed() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().contents(), "");
 
     parser.process(b"foo\x1b[5;5Hbar\x1b[10;10Hbaz\x1b[20;20Hquux");
@@ -319,7 +319,7 @@ fn ed() {
 #[allow(clippy::cognitive_complexity)]
 #[test]
 fn el() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().contents(), "");
 
     parser.process(b"foo\x1b[5;5Hbarbar\x1b[10;10Hbazbaz\x1b[20;20Hquux");
@@ -515,7 +515,7 @@ fn el() {
 
 #[test]
 fn ich_dch_ech() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().contents(), "");
 
     parser.process(b"\x1b[10;10Hfoobar");
@@ -581,7 +581,7 @@ fn ich_dch_ech() {
 
 #[test]
 fn il_dl() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().contents(), "");
 
     parser.process(b"\x1b[10;10Hfoobar\x1b[3D");
@@ -634,7 +634,7 @@ fn il_dl() {
 
 #[test]
 fn scroll() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     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");
diff --git a/tests/escape.rs b/tests/escape.rs
index 2b7b9e4..7a05491 100644
--- a/tests/escape.rs
+++ b/tests/escape.rs
@@ -2,7 +2,7 @@
 
 #[test]
 fn deckpam() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert!(!parser.screen().application_keypad());
     parser.process(b"\x1b=");
     assert!(parser.screen().application_keypad());
@@ -12,7 +12,7 @@ fn deckpam() {
 
 #[test]
 fn ri() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     parser.process(b"foo\nbar\x1bMbaz");
     assert_eq!(parser.screen().contents(), "foo   baz\n   bar");
 
@@ -25,7 +25,7 @@ fn ri() {
 
 #[test]
 fn ris() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().cursor_position(), (0, 0));
 
     let cell = parser.screen().cell(0, 0).unwrap();
@@ -122,7 +122,7 @@ fn ris() {
 
 #[test]
 fn vb() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert!(!parser.screen_mut().check_visual_bell());
     parser.process(b"\x1bg");
     assert!(parser.screen_mut().check_visual_bell());
@@ -131,7 +131,7 @@ fn vb() {
 
 #[test]
 fn decsc() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     parser.process(b"foo\x1b7\r\n\r\n\r\n         bar\x1b8baz");
     assert_eq!(parser.screen().contents(), "foobaz\n\n\n         bar");
     assert_eq!(parser.screen().cursor_position(), (0, 6));
diff --git a/tests/init.rs b/tests/init.rs
index f26eb22..490fe3e 100644
--- a/tests/init.rs
+++ b/tests/init.rs
@@ -2,7 +2,7 @@
 
 #[test]
 fn init() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().size(), (24, 80));
     assert_eq!(parser.screen().cursor_position(), (0, 0));
 
diff --git a/tests/mode.rs b/tests/mode.rs
index e6305a2..da08f51 100644
--- a/tests/mode.rs
+++ b/tests/mode.rs
@@ -2,7 +2,7 @@
 
 #[test]
 fn modes() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert!(!parser.screen().application_keypad());
     assert!(!parser.screen().application_cursor());
     assert!(!parser.screen().hide_cursor());
@@ -319,7 +319,7 @@ fn modes() {
 
 #[test]
 fn alternate_buffer() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
 
     // 47
 
diff --git a/tests/osc.rs b/tests/osc.rs
index 8cf90dd..fc489ec 100644
--- a/tests/osc.rs
+++ b/tests/osc.rs
@@ -1,6 +1,6 @@
 #[test]
 fn title() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().title(), "");
     assert_eq!(parser.screen().icon_name(), "");
     parser.process(b"\x1b]2;it's a title\x07");
@@ -13,7 +13,7 @@ fn title() {
 
 #[test]
 fn icon_name() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().title(), "");
     assert_eq!(parser.screen().icon_name(), "");
     parser.process(b"\x1b]1;it's an icon name\x07");
@@ -26,7 +26,7 @@ fn icon_name() {
 
 #[test]
 fn title_icon_name() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().title(), "");
     assert_eq!(parser.screen().icon_name(), "");
     parser.process(b"\x1b]0;it's both\x07");
@@ -39,7 +39,7 @@ fn title_icon_name() {
 
 #[test]
 fn unknown_sequence() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "");
     parser.process(b"\x1b]499;some long, long string?\x07");
     assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "");
diff --git a/tests/processing.rs b/tests/processing.rs
index 4fdb8cb..7cc384c 100644
--- a/tests/processing.rs
+++ b/tests/processing.rs
@@ -2,7 +2,7 @@
 
 #[test]
 fn split_escape_sequences() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     let contents = parser.screen().contents();
     parser.process(b"abc");
     assert_ne!(parser.screen().contents(), contents);
@@ -193,7 +193,7 @@ fn split_escape_sequences() {
 
 #[test]
 fn split_utf8() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     let contents = parser.screen().contents();
     parser.process(b"a");
     assert_ne!(parser.screen().contents(), contents);
diff --git a/tests/scroll.rs b/tests/scroll.rs
index 2291ca3..2881da6 100644
--- a/tests/scroll.rs
+++ b/tests/scroll.rs
@@ -1,6 +1,6 @@
 #[test]
 fn scroll_regions() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     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(), "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24");
 
@@ -40,7 +40,7 @@ fn scroll_regions() {
 
 #[test]
 fn origin_mode() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
 
     parser.process(b"\x1b[5;15r");
     assert_eq!(parser.screen().cursor_position(), (4, 0));
diff --git a/tests/split-escapes.rs b/tests/split-escapes.rs
index 52cad43..097aa6f 100644
--- a/tests/split-escapes.rs
+++ b/tests/split-escapes.rs
@@ -8,7 +8,7 @@ fn get_file_contents(name: &str) -> Vec<u8> {
 }
 
 fn write_to_parser(chunks: &mut Vec<Vec<u8>>) -> (String, Vec<u8>) {
-    let mut parser = vt100::Parser::new(37, 193);
+    let mut parser = vt100::Parser::new(37, 193, 0);
     for chunk in chunks.iter_mut() {
         parser.process(&chunk);
     }
diff --git a/tests/text.rs b/tests/text.rs
index e588a68..3cd5a78 100644
--- a/tests/text.rs
+++ b/tests/text.rs
@@ -2,7 +2,7 @@
 
 #[test]
 fn ascii() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     parser.process(b"foo");
     assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "f");
     assert_eq!(parser.screen().cell(0, 1).unwrap().contents(), "o");
@@ -14,7 +14,7 @@ fn ascii() {
 
 #[test]
 fn utf8() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     parser.process("café".as_bytes());
     assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "c");
     assert_eq!(parser.screen().cell(0, 1).unwrap().contents(), "a");
@@ -27,7 +27,7 @@ fn utf8() {
 
 #[test]
 fn newlines() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     parser.process(b"f\r\noo\r\nood");
     assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "f");
     assert_eq!(parser.screen().cell(0, 1).unwrap().contents(), "");
@@ -45,7 +45,7 @@ fn newlines() {
 
 #[test]
 fn wide() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     let screen = parser.screen().clone();
     parser.process("aデbネ".as_bytes());
     assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "a");
@@ -135,7 +135,7 @@ fn wide() {
 
 #[test]
 fn combining() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     parser.process(b"a");
     assert_eq!(parser.screen().cell(0, 0).unwrap().contents(), "a");
     parser.process("\u{0301}".as_bytes());
@@ -161,7 +161,7 @@ fn combining() {
 
 #[test]
 fn wrap() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     parser.process(b"0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789");
     assert_eq!(parser.screen().contents(), "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789");
     parser.process(b"\x1b[5H01234567890123456789012345678901234567890123456789012345678901234567890123456789");
diff --git a/tests/weird.rs b/tests/weird.rs
index 6719644..9dd6172 100644
--- a/tests/weird.rs
+++ b/tests/weird.rs
@@ -1,6 +1,6 @@
 #[test]
 fn intermediate_control() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     assert_eq!(parser.screen().cursor_position(), (0, 0));
 
     parser.process(b"\x1b");
diff --git a/tests/window_contents.rs b/tests/window_contents.rs
index 6c0e7db..d7a3b13 100644
--- a/tests/window_contents.rs
+++ b/tests/window_contents.rs
@@ -2,7 +2,7 @@ use std::io::Read as _;
 
 #[test]
 fn formatted() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     compare_formatted(parser.screen());
     assert_eq!(
         parser.screen().contents_formatted(),
@@ -65,7 +65,7 @@ fn formatted() {
 
 #[test]
 fn empty_cells() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     parser.process(b"\x1b[5C\x1b[32m bar\x1b[H\x1b[31mfoo");
     compare_formatted(parser.screen());
     assert_eq!(parser.screen().contents(), "foo   bar");
@@ -77,7 +77,7 @@ fn empty_cells() {
 
 #[test]
 fn cursor_positioning() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     let screen1 = parser.screen().clone();
 
     parser.process(b":\x1b[K");
@@ -115,7 +115,7 @@ fn cursor_positioning() {
 
 #[test]
 fn rows() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     let screen1 = parser.screen().clone();
     assert_eq!(
         screen1.rows(0, 80).collect::<Vec<String>>(),
@@ -423,7 +423,7 @@ fn rows() {
 
 #[test]
 fn diff() {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     let screen1 = parser.screen().clone();
     parser.process(b"\x1b[5C\x1b[32m bar");
     let screen2 = parser.screen().clone();
@@ -471,7 +471,7 @@ fn diff_crawl_full() {
 }
 
 fn diff_crawl(i: usize) {
-    let mut parser = vt100::Parser::new(24, 80);
+    let mut parser = vt100::Parser::new(24, 80, 0);
     let screens: Vec<_> = (1..=i)
         .map(|i| {
             let mut file =
@@ -498,7 +498,7 @@ fn diff_crawl(i: usize) {
 
 fn compare_formatted(screen: &vt100::Screen) {
     let (rows, cols) = screen.size();
-    let mut parser = vt100::Parser::new(rows, cols);
+    let mut parser = vt100::Parser::new(rows, cols, 0);
     let contents = screen.contents_formatted();
     parser.process(&contents);
     compare_cells(screen, parser.screen());
@@ -510,13 +510,13 @@ fn compare_diff(
     prev_parsed: &[u8],
 ) {
     let (rows, cols) = screen.size();
-    let mut parser = vt100::Parser::new(rows, cols);
+    let mut parser = vt100::Parser::new(rows, cols, 0);
     parser.process(prev_parsed);
     // need to reparse the formatted contents here in case we're in the middle
     // of parsing an escape sequence, since applying the diff at that location
     // directly won't work in that case
     let contents = parser.screen().contents_formatted();
-    let mut parser = vt100::Parser::new(rows, cols);
+    let mut parser = vt100::Parser::new(rows, cols, 0);
     parser.process(&contents);
     compare_cells(parser.screen(), &prev_screen);
     assert_eq!(parser.screen().hide_cursor(), prev_screen.hide_cursor());