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 199)

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 theme = load_theme(&options.theme_name)?;
    let mut highlighter = SpanHighlighter::new()?;
    let mut renderer = IncrementalRenderer::new(options.width, options.height);
    renderer.set_origin(options.origin_row, options.origin_col);
    renderer.set_color_mode(options.color_mode);

    if let Some(previous_source_path) = &options.previous_source_path {
        let previous_source = fs::read(previous_source_path)?;
        let _ = renderer.highlight_to_patch(&mut highlighter, &previous_source, grammar, &theme)?;
    }

    let patch = renderer.highlight_to_patch(&mut highlighter, &source, grammar, &theme)?;
    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 200)

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 theme = load_theme(&options.theme_name)?;
    let mut highlighter = SpanHighlighter::new()?;
    let mut renderer = IncrementalRenderer::new(options.width, options.height);
    renderer.set_origin(options.origin_row, options.origin_col);
    renderer.set_color_mode(options.color_mode);

    if let Some(previous_source_path) = &options.previous_source_path {
        let previous_source = fs::read(previous_source_path)?;
        let _ = renderer.highlight_to_patch(&mut highlighter, &previous_source, grammar, &theme)?;
    }

    let patch = renderer.highlight_to_patch(&mut highlighter, &source, grammar, &theme)?;
    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 201)

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 theme = load_theme(&options.theme_name)?;
    let mut highlighter = SpanHighlighter::new()?;
    let mut renderer = IncrementalRenderer::new(options.width, options.height);
    renderer.set_origin(options.origin_row, options.origin_col);
    renderer.set_color_mode(options.color_mode);

    if let Some(previous_source_path) = &options.previous_source_path {
        let previous_source = fs::read(previous_source_path)?;
        let _ = renderer.highlight_to_patch(&mut highlighter, &previous_source, grammar, &theme)?;
    }

    let patch = renderer.highlight_to_patch(&mut highlighter, &source, grammar, &theme)?;
    print!("{patch}");
    io::stdout().flush()?;

    Ok(())
}

pub fn color_mode(&self) -> ColorMode

Returns the current ANSI color mode.

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 205)

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 theme = load_theme(&options.theme_name)?;
    let mut highlighter = SpanHighlighter::new()?;
    let mut renderer = IncrementalRenderer::new(options.width, options.height);
    renderer.set_origin(options.origin_row, options.origin_col);
    renderer.set_color_mode(options.color_mode);

    if let Some(previous_source_path) = &options.previous_source_path {
        let previous_source = fs::read(previous_source_path)?;
        let _ = renderer.highlight_to_patch(&mut highlighter, &previous_source, grammar, &theme)?;
    }

    let patch = renderer.highlight_to_patch(&mut highlighter, &source, grammar, &theme)?;
    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.