fix a couple more issues with end of line behavior

3 files changed, 144 insertions, 16 deletions

diff --git a/src/grid.rs b/src/grid.rs
index 8076a6c..9619443 100644
--- a/src/grid.rs
+++ b/src/grid.rs
@@ -228,9 +228,55 @@ impl Grid {
                     col: self.size.cols - 1,
                 };
             }
-            crate::term::MoveFromTo::new(prev_pos, pos).write_buf(contents);
             let cell = self.visible_cell(pos).unwrap();
-            contents.extend(cell.contents().as_bytes());
+            if cell.has_contents() {
+                crate::term::MoveFromTo::new(prev_pos, pos)
+                    .write_buf(contents);
+                contents.extend(cell.contents().as_bytes());
+            } else {
+                // if the cell doesn't have contents, we can't have gotten
+                // here by drawing a character in the last column. this means
+                // that as far as i'm aware, we have to have reached here from
+                // a newline when we were already after the end of an earlier
+                // row. in the case where we are already after the end of an
+                // earlier row, we can just write a few newlines, otherwise we
+                // also need to do the same as above to get ourselves to after
+                // the end of a row.
+                let orig_row = pos.row;
+                let mut found = false;
+                for i in (0..orig_row).rev() {
+                    pos.row = i;
+                    let cell = self.visible_cell(pos).unwrap();
+                    if cell.has_contents() {
+                        if prev_pos.row != i || prev_pos.col < self.size.cols
+                        {
+                            crate::term::MoveFromTo::new(prev_pos, pos)
+                                .write_buf(contents);
+                            contents.extend(cell.contents().as_bytes());
+                        }
+                        contents.extend(
+                            "\n".repeat((orig_row - i) as usize).as_bytes(),
+                        );
+                        found = true;
+                        break;
+                    }
+                }
+
+                // this can happen if you get the cursor off the end of a row,
+                // and then do something to clear the current row without
+                // moving the cursor (IL, ED, EL, etc). i can't see any way
+                // for this to happen without the entire current row being
+                // cleared (not just the last cell), so this seems
+                // prooooobably fine?
+                if !found {
+                    pos.row = orig_row;
+                    crate::term::MoveFromTo::new(prev_pos, pos)
+                        .write_buf(contents);
+                    contents.push(b' ');
+                    crate::term::ClearRowBackward::default()
+                        .write_buf(contents);
+                }
+            }
         } else {
             crate::term::MoveFromTo::new(prev_pos, self.pos)
                 .write_buf(contents);
@@ -282,9 +328,55 @@ impl Grid {
                     col: self.size.cols - 1,
                 };
             }
-            crate::term::MoveFromTo::new(prev_pos, pos).write_buf(contents);
             let cell = self.visible_cell(pos).unwrap();
-            contents.extend(cell.contents().as_bytes());
+            if cell.has_contents() {
+                crate::term::MoveFromTo::new(prev_pos, pos)
+                    .write_buf(contents);
+                contents.extend(cell.contents().as_bytes());
+            } else {
+                // if the cell doesn't have contents, we can't have gotten
+                // here by drawing a character in the last column. this means
+                // that as far as i'm aware, we have to have reached here from
+                // a newline when we were already after the end of an earlier
+                // row. in the case where we are already after the end of an
+                // earlier row, we can just write a few newlines, otherwise we
+                // also need to do the same as above to get ourselves to after
+                // the end of a row.
+                let orig_row = pos.row;
+                let mut found = false;
+                for i in (0..orig_row).rev() {
+                    pos.row = i;
+                    let cell = self.visible_cell(pos).unwrap();
+                    if cell.has_contents() {
+                        if prev_pos.row != i || prev_pos.col < self.size.cols
+                        {
+                            crate::term::MoveFromTo::new(prev_pos, pos)
+                                .write_buf(contents);
+                            contents.extend(cell.contents().as_bytes());
+                        }
+                        contents.extend(
+                            "\n".repeat((orig_row - i) as usize).as_bytes(),
+                        );
+                        found = true;
+                        break;
+                    }
+                }
+
+                // this can happen if you get the cursor off the end of a row,
+                // and then do something to clear the current row without
+                // moving the cursor (IL, ED, EL, etc). i can't see any way
+                // for this to happen without the entire current row being
+                // cleared (not just the last cell), so this seems
+                // prooooobably fine?
+                if !found {
+                    pos.row = orig_row;
+                    crate::term::MoveFromTo::new(prev_pos, pos)
+                        .write_buf(contents);
+                    contents.push(b' ');
+                    crate::term::ClearRowBackward::default()
+                        .write_buf(contents);
+                }
+            }
         } else {
             crate::term::MoveFromTo::new(prev_pos, self.pos)
                 .write_buf(contents);
@@ -495,9 +587,9 @@ impl Grid {
         self.col_clamp();
     }
 
-    pub fn col_wrap(&mut self, width: u16) {
+    pub fn col_wrap(&mut self, width: u16, wrap: bool) {
         if self.pos.col > self.size.cols - width {
-            self.current_row_mut().wrap(true);
+            self.current_row_mut().wrap(wrap);
             self.pos.col = 0;
             self.row_inc_scroll(1);
         }
diff --git a/src/screen.rs b/src/screen.rs
index ec4d204..07363b1 100644
--- a/src/screen.rs
+++ b/src/screen.rs
@@ -588,19 +588,45 @@ impl Screen {
             }
         }
 
+        let mut wrap = true;
+        // it doesn't make any sense to wrap if the last column in a row
+        // didn't already have contents
+        if pos.col > 1 {
+            let mut prev_cell = self
+                .drawing_cell_mut(crate::grid::Pos {
+                    row: pos.row,
+                    col: pos.col - 2,
+                })
+                .unwrap();
+            if !prev_cell.is_wide() {
+                prev_cell = self
+                    .drawing_cell_mut(crate::grid::Pos {
+                        row: pos.row,
+                        col: pos.col - 1,
+                    })
+                    .unwrap();
+            }
+            if !prev_cell.has_contents() {
+                wrap = false;
+            }
+        }
+
         let width = c.width().unwrap_or(0).try_into().unwrap();
         let attrs = self.attrs;
 
-        // zero width characters still cause the cursor to wrap - this doesn't
-        // affect which cell they go into (the "previous cell" for both (row,
-        // max_col + 1) and (row + 1, 0) is (row, max_col)), but does affect
-        // further movement afterwards - writing an `a` at (row, max_col)
-        // followed by a crlf puts the cursor at (row + 1, 0), but writing a
-        // `à` (specifically `a` followed by a combining grave accent - the
-        // normalized U+00E0 "latin small letter a with grave" behaves the
-        // same as `a`) at (row, max_col) followed by a crlf puts the cursor
-        // at (row + 2, 0)
-        self.grid_mut().col_wrap(if width == 0 { 1 } else { width });
+        self.grid_mut().col_wrap(
+            // zero width characters still cause the cursor to wrap - this
+            // doesn't affect which cell they go into (the "previous cell" for
+            // both (row, max_col + 1) and (row + 1, 0) is (row, max_col)),
+            // but does affect further movement afterwards - writing an `a` at
+            // (row, max_col) followed by a crlf puts the cursor at (row + 1,
+            // 0), but writing a `à` (specifically `a` followed by a combining
+            // grave accent - the normalized U+00E0 "latin small letter a with
+            // grave" behaves the same as `a`) at (row, max_col) followed by a
+            // crlf puts the cursor at (row + 2, 0)
+            if width == 0 { 1 } else { width },
+            wrap,
+        );
 
         if width == 0 {
             if pos.col > 0 {
diff --git a/src/term.rs b/src/term.rs
index d2f7c9b..5a9fbd6 100644
--- a/src/term.rs
+++ b/src/term.rs
@@ -26,6 +26,16 @@ impl BufWrite for ClearRowForward {
 
 #[derive(Default, Debug)]
 #[must_use = "this struct does nothing unless you call write_buf"]
+pub struct ClearRowBackward;
+
+impl BufWrite for ClearRowBackward {
+    fn write_buf(&self, buf: &mut Vec<u8>) {
+        buf.extend_from_slice(b"\x1b[1K");
+    }
+}
+
+#[derive(Default, Debug)]
+#[must_use = "this struct does nothing unless you call write_buf"]
 pub struct CRLF;
 
 impl BufWrite for CRLF {