Fix TTY remapped default background fills

Author: eval-exec

neomacs-display-protocol/src/glyph_matrix.rs

@@ -550,6 +550,21 @@ pub struct BackgroundItem {
     pub color: Color,
 }
 
+/// A rectangular fill painted with a realized face.
+///
+/// This represents redisplay-owned blank cells: areas such as the body text
+/// region of a window whose background comes from buffer-local face remapping.
+/// It is intentionally face-based instead of color-only so TTY backends can
+/// preserve terminal-default foreground/background semantics.
+#[derive(Clone, Debug)]
+pub struct FaceFillItem {
+    pub window_id: DisplayWindowId,
+    pub row_role: GlyphRowRole,
+    pub clip_rect: Option<Rect>,
+    pub bounds: Rect,
+    pub face_id: u32,
+}
+
 /// A window border/divider rectangle.
 #[derive(Clone, Debug)]
 pub struct BorderItem {
@@ -666,6 +681,8 @@ pub struct FrameDisplayState {
     pub transition_hints: Vec<WindowTransitionHint>,
     /// Window background rectangles.
     pub backgrounds: Vec<BackgroundItem>,
+    /// Face-backed rectangular fills for redisplay-owned blank cells.
+    pub face_fills: Vec<FaceFillItem>,
     /// Window border/divider rectangles.
     pub borders: Vec<BorderItem>,
     /// Cursor entries.
@@ -820,6 +837,7 @@ impl FrameDisplayState {
             window_infos: Vec::new(),
             transition_hints: Vec::new(),
             backgrounds: Vec::new(),
+            face_fills: Vec::new(),
             borders: Vec::new(),
             cursors: Vec::new(),
             cursor_effects_by_window: HashMap::new(),
@@ -1145,6 +1163,30 @@ impl FrameDisplayState {
                 color: bg.color,
             });
         }
+        for fill in &self.face_fills {
+            let face_data = self.resolve_face_for_materialize(fill.face_id);
+            push(FrameGlyph::Stretch {
+                window_id: fill.window_id,
+                row_role: fill.row_role,
+                clip_rect: fill.clip_rect,
+                slot_id: DisplaySlotId::from_pixels(
+                    fill.window_id,
+                    fill.bounds.x,
+                    fill.bounds.y,
+                    self.char_width,
+                    self.char_height,
+                ),
+                bidi_level: 0,
+                x: fill.bounds.x,
+                y: fill.bounds.y,
+                width: fill.bounds.width,
+                height: fill.bounds.height,
+                bg: face_data.bg,
+                face_id: fill.face_id,
+                stipple_id: 0,
+                stipple_fg: None,
+            });
+        }
 
         // --- Materialize grid content -> pixel-positioned Char/Stretch glyphs ---
         for frame_row in &self.frame_chrome_rows {

neomacs-display-protocol/src/tty_rif.rs

@@ -361,6 +361,10 @@ impl TtyRif {
             };
         }
 
+        for fill in &state.face_fills {
+            self.rasterize_face_fill(origin_col, origin_row, state, fill);
+        }
+
         for frame_row in &state.frame_chrome_rows {
             let char_w = state.char_width.max(1.0);
             let win_col = origin_col + (frame_row.pixel_bounds.x / char_w) as usize;
@@ -687,6 +691,35 @@ impl TtyRif {
         std::mem::take(&mut self.output)
     }
 
+    fn rasterize_face_fill(
+        &mut self,
+        origin_col: usize,
+        origin_row: usize,
+        state: &FrameDisplayState,
+        fill: &FaceFillItem,
+    ) {
+        let char_w = state.char_width.max(1.0);
+        let char_h = state.char_height.max(1.0);
+        let start_col = origin_col + (fill.bounds.x / char_w).round().max(0.0) as usize;
+        let start_row = origin_row + (fill.bounds.y / char_h).round().max(0.0) as usize;
+        let width_cols = (fill.bounds.width / char_w).ceil().max(0.0) as usize;
+        let height_rows = (fill.bounds.height / char_h).ceil().max(0.0) as usize;
+        if width_cols == 0 || height_rows == 0 {
+            return;
+        }
+
+        let attrs = self.resolve_attrs(fill.face_id);
+        let max_row = start_row
+            .saturating_add(height_rows)
+            .min(self.desired.height);
+        let max_col = start_col.saturating_add(width_cols).min(self.desired.width);
+        for row in start_row..max_row {
+            for col in start_col..max_col {
+                self.desired.set(row, col, ' ', attrs, false);
+            }
+        }
+    }
+
     fn rasterize_glyph_row(
         &mut self,
         screen_col_start: usize,

neomacs-display-protocol/src/tty_rif_test.rs

@@ -2,7 +2,7 @@ use super::*;
 use crate::face::{Face, FaceAttributes, UnderlineStyle};
 use crate::frame_glyphs::{CursorStyle, DisplaySlotId, GlyphRowRole, PhysCursor};
 use crate::glyph_matrix::{
-    FrameDisplayState, Glyph, GlyphArea, GlyphMatrix, GlyphRow, WindowMatrixEntry,
+    FaceFillItem, FrameDisplayState, Glyph, GlyphArea, GlyphMatrix, GlyphRow, WindowMatrixEntry,
 };
 use crate::types::{Color, DisplayFrameId, DisplayWindowId, Rect};
 use std::collections::HashMap;
@@ -304,6 +304,48 @@ fn rasterize_respects_matrix_position() {
     assert_eq!(rif.desired.cells[0].ch, ' ');
 }
 
+#[test]
+fn rasterize_face_fill_paints_blank_cells_before_glyphs() {
+    let mut state = FrameDisplayState::new(8, 2, 1.0, 1.0);
+    state.background = Color::from_pixel(0x000000);
+    let mut fill_face = Face::new(7);
+    fill_face.background = Color::from_pixel(0x112233);
+    let mut glyph_face = Face::new(8);
+    glyph_face.background = Color::from_pixel(0x445566);
+    state.faces.insert(7, fill_face);
+    state.faces.insert(8, glyph_face);
+    state.face_fills.push(FaceFillItem {
+        window_id: DisplayWindowId::new(1),
+        row_role: GlyphRowRole::Text,
+        clip_rect: Some(Rect::new(0.0, 0.0, 8.0, 2.0)),
+        bounds: Rect::new(0.0, 0.0, 8.0, 1.0),
+        face_id: 7,
+    });
+
+    let mut matrix = GlyphMatrix::new(1, 6);
+    let mut row = GlyphRow::new(GlyphRowRole::Text);
+    row.glyphs[GlyphArea::Text as usize].push(Glyph::char('X', 8, 0));
+    matrix.rows[0] = row;
+    state.window_matrices.push(WindowMatrixEntry {
+        window_id: 1,
+        matrix,
+        pixel_bounds: Rect::new(0.0, 0.0, 8.0, 1.0),
+        text_pixel_bounds: Rect::new(2.0, 0.0, 6.0, 1.0),
+        selected: true,
+    });
+
+    let mut rif = TtyRif::new(8, 2);
+    rif.rasterize(&state);
+
+    assert_eq!(rif.desired.cells[0].ch, ' ');
+    assert_eq!(rif.desired.cells[0].attrs.bg, Some((0x11, 0x22, 0x33)));
+    assert_eq!(rif.desired.cells[1].attrs.bg, Some((0x11, 0x22, 0x33)));
+    assert_eq!(rif.desired.cells[2].ch, 'X');
+    assert_eq!(rif.desired.cells[2].attrs.bg, Some((0x44, 0x55, 0x66)));
+    assert_eq!(rif.desired.cells[7].attrs.bg, Some((0x11, 0x22, 0x33)));
+    assert_eq!(rif.desired.cells[8].attrs.bg, Some((0, 0, 0)));
+}
+
 #[test]
 fn rasterize_uses_grid_rows_not_pixel_row_metrics() {
     let mut state = FrameDisplayState::new(12, 5, 1.0, 1.0);

neomacs-layout-engine/src/display_buffer_source_render_plan.rs

@@ -27,7 +27,9 @@ use crate::font_metrics::FontMetricsService;
 use crate::neovm_bridge::{FaceResolver, LayoutBufferView, ResolvedFace, RustBufferAccess};
 use crate::types::WindowParams;
 use crate::window_output::render_window_chrome_rows;
-use neomacs_display_protocol::types::{Color, Rect};
+use neomacs_display_protocol::frame_glyphs::GlyphRowRole;
+use neomacs_display_protocol::glyph_matrix::FaceFillItem;
+use neomacs_display_protocol::types::{Color, DisplayWindowId, Rect};
 use neovm_core::buffer::BufferId;
 use neovm_core::window::{FrameId, WindowId};
 
@@ -424,6 +426,22 @@ impl BufferSourceOutputSetup {
         }
 
         let (mut output, evaluator) = output.into_parts();
+        if !default_face.face().use_default_background && geometry.text_height > 0.0 {
+            let face_id = face_ids.allocate();
+            output.install_resolved_face(face_id, default_face.face(), None);
+            output.builder().add_output_face_fill(FaceFillItem {
+                window_id: DisplayWindowId::new(params.window_id),
+                row_role: GlyphRowRole::Text,
+                clip_rect: Some(params.bounds),
+                bounds: Rect::new(
+                    params.bounds.x,
+                    geometry.text_y,
+                    params.bounds.width,
+                    geometry.text_height,
+                ),
+                face_id,
+            });
+        }
         let mut render_services =
             ChromeRowRenderServices::new(font_metrics, face_resolver, &mut face_ids);
         let mut output_emitter = output_emitter;

neomacs-layout-engine/src/display_output_builder.rs

@@ -365,6 +365,10 @@ impl DisplayOutputBuilder {
         });
     }
 
+    pub(crate) fn add_output_face_fill(&mut self, item: FaceFillItem) {
+        self.install_output_frame_artifact(OutputFrameArtifactInstallRequest::FaceFill(item));
+    }
+
     pub(crate) fn add_output_border(
         &mut self,
         window_id: i64,

neomacs-layout-engine/src/display_output_frame_state.rs

@@ -10,14 +10,15 @@ use neomacs_display_protocol::frame_glyphs::{
     PhysCursor, WindowEffectHint, WindowInfo, WindowTransitionHint,
 };
 use neomacs_display_protocol::glyph_matrix::{
-    BackgroundItem, BorderItem, CursorItem, FrameDisplayState, ImageItem, ScrollBarItem, VideoItem,
-    XwidgetItem,
+    BackgroundItem, BorderItem, CursorItem, FaceFillItem, FrameDisplayState, ImageItem,
+    ScrollBarItem, VideoItem, XwidgetItem,
 };
 use neomacs_display_protocol::types::{Color, DisplayFrameId, DisplayWindowId};
 use std::collections::HashMap;
 
 pub(crate) struct OutputFrameBuildState {
     backgrounds: Vec<BackgroundItem>,
+    face_fills: Vec<FaceFillItem>,
     borders: Vec<BorderItem>,
     cursors: Vec<CursorItem>,
     images: Vec<ImageItem>,
@@ -48,6 +49,7 @@ impl OutputFrameBuildState {
     pub(crate) fn new() -> Self {
         Self {
             backgrounds: Vec::new(),
+            face_fills: Vec::new(),
             borders: Vec::new(),
             cursors: Vec::new(),
             images: Vec::new(),
@@ -87,6 +89,7 @@ impl OutputFrameBuildState {
 
     pub(crate) fn reset(&mut self) {
         self.backgrounds.clear();
+        self.face_fills.clear();
         self.borders.clear();
         self.cursors.clear();
         self.images.clear();
@@ -146,6 +149,9 @@ impl OutputFrameBuildState {
             OutputFrameArtifactInstallRequest::Background { bounds, color } => {
                 self.backgrounds.push(BackgroundItem { bounds, color });
             }
+            OutputFrameArtifactInstallRequest::FaceFill(item) => {
+                self.face_fills.push(item);
+            }
             OutputFrameArtifactInstallRequest::Border {
                 window_id,
                 x,
@@ -284,6 +290,7 @@ impl OutputFrameBuildState {
 
     pub(crate) fn install_into(self, state: &mut FrameDisplayState) {
         state.backgrounds = self.backgrounds;
+        state.face_fills = self.face_fills;
         state.borders = self.borders;
         state.cursors = self.cursors;
         state.images = self.images;

neomacs-layout-engine/src/display_output_install_request.rs

@@ -6,7 +6,7 @@ use neomacs_display_protocol::frame_glyphs::{
     CursorStyle, DisplaySlotId, GlyphRowRole, PhysCursor, WindowEffectHint, WindowInfo,
     WindowTransitionHint,
 };
-use neomacs_display_protocol::glyph_matrix::{CursorItem, ScrollBarItem};
+use neomacs_display_protocol::glyph_matrix::{CursorItem, FaceFillItem, ScrollBarItem};
 use neomacs_display_protocol::types::{
     Color, DisplayFrameId, DisplayWindowId, ImageId, Rect, VideoId, XwidgetId,
 };
@@ -197,6 +197,7 @@ pub(crate) enum OutputFrameArtifactInstallRequest {
         bounds: Rect,
         color: Color,
     },
+    FaceFill(FaceFillItem),
     Border {
         window_id: DisplayWindowId,
         x: f32,