fix(cell): draw spaces into a freshly cleared screen

After Init or Resume, the first frame skips every cell that the
application fills with a space in the default style. The terminal keeps
showing the blank cells left by clearing the screen. Most terminals draw
a blank cell and a space the same way, but kitty does not. It draws a
symbol from the private use area, such as a Nerd Font icon, over two
cells only if an actual space follows it, and scales it down to one cell
otherwise. File icons in lazygit come out too small for this reason
until something redraws the cells after them. See kovidgoyal/kitty#10790
for an analysis.

Marking a cell dirty changes lastStr so that it differs from currStr. It
becomes an empty string, or a space if the cell has never been drawn. If
the application then puts that same value into the cell without changing
its style, Dirty sees no difference and the cell is not drawn. At
startup and after Resume, CellBuffer.Resize marks all cells dirty while
they are still empty, so the first frame skips every space in the
default style.

This is a regression. The space marker for cells that have never been
drawn came with gdamore#1108 (v3.4.0), and it was meant to force a redraw of
such cells. Startup has skipped the spaces since then. Resume has
skipped them since gdamore#1176 (v3.6.0) made Resize mark new cells dirty.

Record a redraw in a flag of its own, so that nothing put into the cell
can make it clean before it is drawn. The first frame after Init or
Resume now writes every blank cell again, as v3.3.0 did. This is about
as much output as a redraw after resizing the window. For lazygit in a
250x70 terminal, the output at startup grows from 10 KB to 25 KB, and a
single resize redraw is 23 KB. Later frames are unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: 2 people

cell.go

@@ -23,20 +23,15 @@ type cell struct {
 	lastStyle Style
 	width     int
 	lock      bool
-	lastWidth int8 // width of lastStr, or 0 when lastStr marks a redraw
+	redraw    bool // draw the cell even if its content and style are unchanged
+	lastWidth int8 // width of lastStr, or 0 while redraw is set
 }
 
 func (c *cell) setDirty(dirty bool) {
+	c.redraw = dirty
 	if dirty {
-		// Empty cells use currStr == "" until they are first drawn, at which
-		// point SetDirty(false) normalizes them to a space.  Using "" as the
-		// dirty marker for an untouched empty cell would therefore leave
-		// lastStr == currStr and fail to force a redraw.
-		if c.currStr == "" {
-			c.lastStr = " "
-		} else {
-			c.lastStr = ""
-		}
+		// What the terminal shows is unknown until the cell is drawn.
+		c.lastStr = ""
 		c.lastWidth = 0
 	} else {
 		if c.currStr == "" {
@@ -159,14 +154,18 @@ func (cb *CellBuffer) Invalidate() {
 }
 
 // Dirty checks if a character at the given location needs to be
-// refreshed on the physical display.  This returns true if the cell
-// content is different since the last time it was marked clean.
+// refreshed on the physical display.  This returns true if the cell was
+// marked dirty, or if its content is different since the last time it
+// was marked clean.
 func (cb *CellBuffer) Dirty(x, y int) bool {
 	if x >= 0 && y >= 0 && x < cb.w && y < cb.h {
 		c := &cb.cells[(y*cb.w)+x]
 		if c.lock {
 			return false
 		}
+		if c.redraw {
+			return true
+		}
 		if c.lastStyle != c.currStyle {
 			return true
 		}

cell_test.go

@@ -113,6 +113,26 @@ func TestCellBufferDirtyState(t *testing.T) {
 	}
 }
 
+// A cell that is marked dirty must be drawn even if a blank is put into it
+// before the next draw.
+func TestCellBufferBlankKeepsDirtyCellDirty(t *testing.T) {
+	for _, drawn := range []bool{false, true} {
+		for _, blank := range []string{"", " "} {
+			cb := &CellBuffer{}
+			cb.Resize(1, 1) // marks the cell dirty
+			if drawn {
+				cb.Put(0, 0, "x", StyleDefault)
+				cb.SetDirty(0, 0, false)
+				cb.Invalidate()
+			}
+			cb.Put(0, 0, blank, StyleDefault)
+			if !cb.Dirty(0, 0) {
+				t.Errorf("drawn=%v, put %q: the cell is no longer dirty", drawn, blank)
+			}
+		}
+	}
+}
+
 func TestCellBufferLockResizeFill(t *testing.T) {
 	cb := &CellBuffer{w: 2, h: 2, cells: make([]cell, 4)}
 	cb.Fill('x', StyleDefault)

tscreen_test.go

@@ -775,6 +775,51 @@ func TestUnlockRegionRedrawsUntouchedBlankCell(t *testing.T) {
 	}
 }
 
+// After the screen is cleared, the terminal shows blank cells, not spaces.
+// Some terminals treat the two differently. kitty, for example, draws a
+// private use symbol such as a Nerd Font icon over two cells only if an
+// actual space follows it. So the first frame after clearing the screen
+// must write the spaces it puts, both at startup and after resuming.
+func TestSpacesAreDrawnAfterClearingTheScreen(t *testing.T) {
+	t.Setenv("LC_ALL", "en_US.UTF-8")
+	frame := func(scr Screen) {
+		scr.Clear()
+		scr.Put(0, 0, "\uf313", StyleDefault)
+		scr.Put(1, 0, " ", StyleDefault)
+		scr.Put(2, 0, "a", StyleDefault)
+		scr.Show()
+	}
+	expectSpaceAfterSymbol := func(t *testing.T, mt vt.MockTerm) {
+		t.Helper()
+		if got := mt.GetCell(vt.Coord{X: 1}); got.C != " " {
+			t.Fatalf("terminal shows %q after the symbol, want a space", got.C)
+		}
+	}
+
+	t.Run("startup", func(t *testing.T) {
+		mt, scr := NewMockScreen(t, vt.MockOptSize{X: 3, Y: 1})
+		defer scr.Fini()
+
+		frame(scr)
+		expectSpaceAfterSymbol(t, mt)
+	})
+
+	t.Run("resume", func(t *testing.T) {
+		mt, scr := NewMockScreen(t, vt.MockOptSize{X: 3, Y: 1})
+		defer scr.Fini()
+
+		frame(scr)
+		if err := scr.Suspend(); err != nil {
+			t.Fatalf("failed to suspend screen: %v", err)
+		}
+		if err := scr.Resume(); err != nil {
+			t.Fatalf("failed to resume screen: %v", err)
+		}
+		frame(scr)
+		expectSpaceAfterSymbol(t, mt)
+	})
+}
+
 // Redrawing an unchanged wide character after Clear, as immediate-mode
 // apps do every frame, must not send it again; a changed one must be sent.
 func TestWideCharAfterClear(t *testing.T) {