Clear widget does not clear area

Help
1

full code here

I am rendering a log feed for a p2p rendezvous server. When the box first renders, everything is correct, but the second render (log added) causes it to break. I’ve attached an image of what that looks like. It works fine if I call terminal.clear() before drawing, but that causes alot of flickering.

pub struct Logs {
    pub init_error: Option<String>,
    pub items: VecDeque<String>,
}

impl Logs {
    pub fn get_text(&mut self, rect: Rect) -> impl Iterator<Item=Line<'_>> {
        self.items
            .iter()
            .rev()
            .take(rect.height as usize - 2)
            .rev()
            .map(|s| Line::from(s.as_str()))
    }
}

pub fn render_logs_box(frame: &mut Frame, state: &mut State, area: Rect) {
    let block = Block::bordered().title("Logs");
    let text = state.logs.get_text(area);
    let widget = Paragraph::new(Text::from_iter(text))
        .block(block)
        .left_aligned()
        .wrap(Wrap { trim: false });

      frame.render_widget(Clear, area);
      frame.render_widget(widget, area);
}

image
image713×579 44.1 KB

2

It looks like the Session start messages are writing to the stdout (or stderr possibly), and are conflicting with the state that Ratatui keeps in the two buffers. See Rendering under the hood | Ratatui for more info on how this works. Ratatui only writes the diff between the buffer states, not the full screen.

The Clear widget is only for helping make that transition from two known states. Its one job is to write empty spaces to areas of the buffer that might have previously been written with non-empty cells. This is needed as most widgets only modify the specific ares that they need to rather than blanking out the entire area.

But those rendering actions are only against the buffers, Ratatui’s understanding of what the terminal should hold after each frame. If you modify the actual terminal contents from some other part of your applicaiton, then Ratatui doesn’t know that it needs to redraw that area.

I suspect additionally that the Session start messages are also coming from another thread which happens to run at the same time as the render calls that Ratatui makes when it calls Terminal::flush() from draw().

We don’t have a good way (yet) to force Ratatui to treat the screen as having junk information that always needs to be rewritten. The right way of fixing this problem is to remove that “Session Start” output from being written.

A bit of a hacky workaround to force Ratatui to always render the full buffer if you need it (there may be other ways, but I think this one will work) is to write a junk character to every cell of the buffer using Terminal::get_buffer_mut(), then flip the two buffers with Terminal::swap(). This makes the next time that you draw diff against the junk character (choose one that will never be in your app UI) and always come up different, which will cause every screen cell to be written. This is much slower than the diff approach, but it avoids the screen flicker of doing a full clear screen. You should in general not notice writing the same character over an existing character.

There’s a related issue for making the diffing stuff better in Allow forcing an area to be redrawn · Issue #1606 · ratatui/ratatui · GitHub

Aside: one thing you should do generally is run your app in release mode to avoid the above mentioned rendering slowness - there’s a massive difference in terminal rendering speed between debug and release mode.

3

I’m using a custom log writer that should prevent output from being written to stdout. I’ll have to ask the tracing people how I can confirm that.

Thanks for your response