Struct IncrementalRenderer 

pub struct IncrementalRenderer { /* private fields */ }

Implementations

impl IncrementalRenderer

pub fn new(width: usize, height: usize) -> Self

Creates an incremental renderer with a bounded viewport size.

A minimum viewport size of 1x1 is enforced. The render origin defaults to terminal row 1, column 1.

Examples found in repository

examples/vt_patch_bridge.rs (line 300)

fn main() -> Result<(), Box<dyn Error>> {
    let args: Vec<String> = env::args().collect();
    let options = match parse_args(&args) {
        Ok(options) => options,
        Err(err) => {
            eprintln!("invalid arguments: {err}");
            eprintln!();
            print_usage();
            return Ok(());
        }
    };

    let grammar =
        parse_grammar(&options.grammar_name).map_err(|msg| format!("invalid grammar: {msg}"))?;
    let source = fs::read(&options.source_path)?;
    let previous_source = if let Some(previous_source_path) = &options.previous_source_path {
        Some(fs::read(previous_source_path)?)
    } else {
        None
    };
    let theme = load_theme(&options.theme_name)?;
    let mut highlighter = SpanHighlighter::new()?;

    let patch = if let Some(origin_row) = options.origin_row {
        let mut renderer = IncrementalRenderer::new(options.width, options.height);
        renderer.set_origin(origin_row, options.origin_col);
        renderer.set_color_mode(options.color_mode);
        renderer.set_preserve_terminal_background(options.preserve_terminal_background);

        if let Some(previous_source) = previous_source.as_deref() {
            let _ =
                renderer.highlight_to_patch(&mut highlighter, previous_source, grammar, &theme)?;
        }

        renderer.highlight_to_patch(&mut highlighter, &source, grammar, &theme)?
    } else {
        let source_is_multiline = source.contains(&b'\n');
        let previous_is_multiline = previous_source
            .as_ref()
            .is_some_and(|snapshot| snapshot.contains(&b'\n'));

        if source_is_multiline || previous_is_multiline {
            let rendered = highlight_to_ansi_with_highlighter_and_mode_and_background(
                &mut highlighter,
                &source,
                grammar,
                &theme,
                options.color_mode,
                options.preserve_terminal_background,
            )?;
            build_full_rerender_patch(rendered, previous_source.as_deref())
        } else {
            let mut renderer = StreamLineRenderer::new();
            renderer.set_color_mode(options.color_mode);
            renderer.set_preserve_terminal_background(options.preserve_terminal_background);

            if let Some(previous_source) = previous_source.as_deref() {
                let _ = renderer
                    .highlight_line_to_patch(&mut highlighter, previous_source, grammar, &theme)
                    .map_err(streamline_mode_error)?;
            }

            renderer
                .highlight_line_to_patch(&mut highlighter, &source, grammar, &theme)
                .map_err(streamline_mode_error)?
        }
    };

    print!("{patch}");
    io::stdout().flush()?;

    Ok(())
}

pub fn resize(&mut self, width: usize, height: usize)

Resizes the viewport and clips cached state to the new bounds.

pub fn clear_state(&mut self)

Clears all cached frame state for this renderer.

pub fn set_origin(&mut self, row: usize, col: usize)

Sets the terminal origin used for generated CUP cursor positions.

The origin is 1-based terminal coordinates (row, col) in display cells. Values lower than 1 are clamped to 1.

Examples found in repository

examples/vt_patch_bridge.rs (line 301)

fn main() -> Result<(), Box<dyn Error>> {
    let args: Vec<String> = env::args().collect();
    let options = match parse_args(&args) {
        Ok(options) => options,
        Err(err) => {
            eprintln!("invalid arguments: {err}");
            eprintln!();
            print_usage();
            return Ok(());
        }
    };

    let grammar =
        parse_grammar(&options.grammar_name).map_err(|msg| format!("invalid grammar: {msg}"))?;
    let source = fs::read(&options.source_path)?;
    let previous_source = if let Some(previous_source_path) = &options.previous_source_path {
        Some(fs::read(previous_source_path)?)
    } else {
        None
    };
    let theme = load_theme(&options.theme_name)?;
    let mut highlighter = SpanHighlighter::new()?;

    let patch = if let Some(origin_row) = options.origin_row {
        let mut renderer = IncrementalRenderer::new(options.width, options.height);
        renderer.set_origin(origin_row, options.origin_col);
        renderer.set_color_mode(options.color_mode);
        renderer.set_preserve_terminal_background(options.preserve_terminal_background);

        if let Some(previous_source) = previous_source.as_deref() {
            let _ =
                renderer.highlight_to_patch(&mut highlighter, previous_source, grammar, &theme)?;
        }

        renderer.highlight_to_patch(&mut highlighter, &source, grammar, &theme)?
    } else {
        let source_is_multiline = source.contains(&b'\n');
        let previous_is_multiline = previous_source
            .as_ref()
            .is_some_and(|snapshot| snapshot.contains(&b'\n'));

        if source_is_multiline || previous_is_multiline {
            let rendered = highlight_to_ansi_with_highlighter_and_mode_and_background(
                &mut highlighter,
                &source,
                grammar,
                &theme,
                options.color_mode,
                options.preserve_terminal_background,
            )?;
            build_full_rerender_patch(rendered, previous_source.as_deref())
        } else {
            let mut renderer = StreamLineRenderer::new();
            renderer.set_color_mode(options.color_mode);
            renderer.set_preserve_terminal_background(options.preserve_terminal_background);

            if let Some(previous_source) = previous_source.as_deref() {
                let _ = renderer
                    .highlight_line_to_patch(&mut highlighter, previous_source, grammar, &theme)
                    .map_err(streamline_mode_error)?;
            }

            renderer
                .highlight_line_to_patch(&mut highlighter, &source, grammar, &theme)
                .map_err(streamline_mode_error)?
        }
    };

    print!("{patch}");
    io::stdout().flush()?;

    Ok(())
}

pub fn origin(&self) -> (usize, usize)

Returns the current 1-based terminal origin (row, col).

pub fn set_color_mode(&mut self, color_mode: ColorMode)

Sets the ANSI color mode used by this renderer.

Examples found in repository

examples/vt_patch_bridge.rs (line 302)

fn main() -> Result<(), Box<dyn Error>> {
    let args: Vec<String> = env::args().collect();
    let options = match parse_args(&args) {
        Ok(options) => options,
        Err(err) => {
            eprintln!("invalid arguments: {err}");
            eprintln!();
            print_usage();
            return Ok(());
        }
    };

    let grammar =
        parse_grammar(&options.grammar_name).map_err(|msg| format!("invalid grammar: {msg}"))?;
    let source = fs::read(&options.source_path)?;
    let previous_source = if let Some(previous_source_path) = &options.previous_source_path {
        Some(fs::read(previous_source_path)?)
    } else {
        None
    };
    let theme = load_theme(&options.theme_name)?;
    let mut highlighter = SpanHighlighter::new()?;

    let patch = if let Some(origin_row) = options.origin_row {
        let mut renderer = IncrementalRenderer::new(options.width, options.height);
        renderer.set_origin(origin_row, options.origin_col);
        renderer.set_color_mode(options.color_mode);
        renderer.set_preserve_terminal_background(options.preserve_terminal_background);

        if let Some(previous_source) = previous_source.as_deref() {
            let _ =
                renderer.highlight_to_patch(&mut highlighter, previous_source, grammar, &theme)?;
        }

        renderer.highlight_to_patch(&mut highlighter, &source, grammar, &theme)?
    } else {
        let source_is_multiline = source.contains(&b'\n');
        let previous_is_multiline = previous_source
            .as_ref()
            .is_some_and(|snapshot| snapshot.contains(&b'\n'));

        if source_is_multiline || previous_is_multiline {
            let rendered = highlight_to_ansi_with_highlighter_and_mode_and_background(
                &mut highlighter,
                &source,
                grammar,
                &theme,
                options.color_mode,
                options.preserve_terminal_background,
            )?;
            build_full_rerender_patch(rendered, previous_source.as_deref())
        } else {
            let mut renderer = StreamLineRenderer::new();
            renderer.set_color_mode(options.color_mode);
            renderer.set_preserve_terminal_background(options.preserve_terminal_background);

            if let Some(previous_source) = previous_source.as_deref() {
                let _ = renderer
                    .highlight_line_to_patch(&mut highlighter, previous_source, grammar, &theme)
                    .map_err(streamline_mode_error)?;
            }

            renderer
                .highlight_line_to_patch(&mut highlighter, &source, grammar, &theme)
                .map_err(streamline_mode_error)?
        }
    };

    print!("{patch}");
    io::stdout().flush()?;

    Ok(())
}

pub fn color_mode(&self) -> ColorMode

Returns the current ANSI color mode.

pub fn set_preserve_terminal_background( &mut self, preserve_terminal_background: bool, )

Controls whether ANSI rendering preserves the terminal’s existing background.

When set to true (default), background colors from the theme are ignored. When set to false, background colors from resolved theme styles are emitted.

Examples found in repository

examples/vt_patch_bridge.rs (line 303)

fn main() -> Result<(), Box<dyn Error>> {
    let args: Vec<String> = env::args().collect();
    let options = match parse_args(&args) {
        Ok(options) => options,
        Err(err) => {
            eprintln!("invalid arguments: {err}");
            eprintln!();
            print_usage();
            return Ok(());
        }
    };

    let grammar =
        parse_grammar(&options.grammar_name).map_err(|msg| format!("invalid grammar: {msg}"))?;
    let source = fs::read(&options.source_path)?;
    let previous_source = if let Some(previous_source_path) = &options.previous_source_path {
        Some(fs::read(previous_source_path)?)
    } else {
        None
    };
    let theme = load_theme(&options.theme_name)?;
    let mut highlighter = SpanHighlighter::new()?;

    let patch = if let Some(origin_row) = options.origin_row {
        let mut renderer = IncrementalRenderer::new(options.width, options.height);
        renderer.set_origin(origin_row, options.origin_col);
        renderer.set_color_mode(options.color_mode);
        renderer.set_preserve_terminal_background(options.preserve_terminal_background);

        if let Some(previous_source) = previous_source.as_deref() {
            let _ =
                renderer.highlight_to_patch(&mut highlighter, previous_source, grammar, &theme)?;
        }

        renderer.highlight_to_patch(&mut highlighter, &source, grammar, &theme)?
    } else {
        let source_is_multiline = source.contains(&b'\n');
        let previous_is_multiline = previous_source
            .as_ref()
            .is_some_and(|snapshot| snapshot.contains(&b'\n'));

        if source_is_multiline || previous_is_multiline {
            let rendered = highlight_to_ansi_with_highlighter_and_mode_and_background(
                &mut highlighter,
                &source,
                grammar,
                &theme,
                options.color_mode,
                options.preserve_terminal_background,
            )?;
            build_full_rerender_patch(rendered, previous_source.as_deref())
        } else {
            let mut renderer = StreamLineRenderer::new();
            renderer.set_color_mode(options.color_mode);
            renderer.set_preserve_terminal_background(options.preserve_terminal_background);

            if let Some(previous_source) = previous_source.as_deref() {
                let _ = renderer
                    .highlight_line_to_patch(&mut highlighter, previous_source, grammar, &theme)
                    .map_err(streamline_mode_error)?;
            }

            renderer
                .highlight_line_to_patch(&mut highlighter, &source, grammar, &theme)
                .map_err(streamline_mode_error)?
        }
    };

    print!("{patch}");
    io::stdout().flush()?;

    Ok(())
}

pub fn preserve_terminal_background(&self) -> bool

Returns whether terminal background passthrough is enabled.

pub fn render_patch( &mut self, source: &[u8], spans: &[StyledSpan], ) -> Result<String, RenderError>

Renders only the VT patch from the cached frame to source.

The method validates input spans, projects them to styled terminal cells, diffs against previous state, and returns only changed cursor/style output.

Errors

Returns an error when spans are out of bounds, unsorted, or overlapping.

pub fn highlight_to_patch( &mut self, highlighter: &mut SpanHighlighter, source: &[u8], flavor: Grammar, theme: &Theme, ) -> Result<String, RenderError>

Runs highlight + theme resolution + incremental diff in one call.

Errors

Returns an error if highlighting fails or spans fail validation.

Examples found in repository

examples/vt_patch_bridge.rs (line 307)

fn main() -> Result<(), Box<dyn Error>> {
    let args: Vec<String> = env::args().collect();
    let options = match parse_args(&args) {
        Ok(options) => options,
        Err(err) => {
            eprintln!("invalid arguments: {err}");
            eprintln!();
            print_usage();
            return Ok(());
        }
    };

    let grammar =
        parse_grammar(&options.grammar_name).map_err(|msg| format!("invalid grammar: {msg}"))?;
    let source = fs::read(&options.source_path)?;
    let previous_source = if let Some(previous_source_path) = &options.previous_source_path {
        Some(fs::read(previous_source_path)?)
    } else {
        None
    };
    let theme = load_theme(&options.theme_name)?;
    let mut highlighter = SpanHighlighter::new()?;

    let patch = if let Some(origin_row) = options.origin_row {
        let mut renderer = IncrementalRenderer::new(options.width, options.height);
        renderer.set_origin(origin_row, options.origin_col);
        renderer.set_color_mode(options.color_mode);
        renderer.set_preserve_terminal_background(options.preserve_terminal_background);

        if let Some(previous_source) = previous_source.as_deref() {
            let _ =
                renderer.highlight_to_patch(&mut highlighter, previous_source, grammar, &theme)?;
        }

        renderer.highlight_to_patch(&mut highlighter, &source, grammar, &theme)?
    } else {
        let source_is_multiline = source.contains(&b'\n');
        let previous_is_multiline = previous_source
            .as_ref()
            .is_some_and(|snapshot| snapshot.contains(&b'\n'));

        if source_is_multiline || previous_is_multiline {
            let rendered = highlight_to_ansi_with_highlighter_and_mode_and_background(
                &mut highlighter,
                &source,
                grammar,
                &theme,
                options.color_mode,
                options.preserve_terminal_background,
            )?;
            build_full_rerender_patch(rendered, previous_source.as_deref())
        } else {
            let mut renderer = StreamLineRenderer::new();
            renderer.set_color_mode(options.color_mode);
            renderer.set_preserve_terminal_background(options.preserve_terminal_background);

            if let Some(previous_source) = previous_source.as_deref() {
                let _ = renderer
                    .highlight_line_to_patch(&mut highlighter, previous_source, grammar, &theme)
                    .map_err(streamline_mode_error)?;
            }

            renderer
                .highlight_line_to_patch(&mut highlighter, &source, grammar, &theme)
                .map_err(streamline_mode_error)?
        }
    };

    print!("{patch}");
    io::stdout().flush()?;

    Ok(())
}

Trait Implementations

impl Clone for IncrementalRenderer

fn clone(&self) -> IncrementalRenderer

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for IncrementalRenderer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.