Struct RenderedGraph 

pub struct RenderedGraph<N, E> { /* private fields */ }

A rendered graph ready for display in a TUI.

The graph structure is immutable after creation, but colors and styles can be modified at any time.

Implementations

impl<N: Display + Clone, E: Display + Clone> RenderedGraph<N, E>

pub fn from_graph(graph: DiGraph<N, E>) -> Self

Create a new rendered graph from a petgraph DiGraph.

pub fn builder() -> RenderedGraphBuilder<N, E>

Create a builder for more configuration options.

Examples found in repository

examples/circular.rs (line 20)

fn main() {
    // Create a graph with circular edges (T <-> U)
    let mut graph: DiGraph<&str, &str> = DiGraph::new();

    let t = graph.add_node("T: Task");
    let u = graph.add_node("U: User");

    // Bidirectional edges - these would overlap without parallel edge handling
    graph.add_edge(t, u, "question");
    graph.add_edge(u, t, "answer");

    let mut rendered = RenderedGraph::builder()
        .graph(graph)
        .border_style(BoxBorder::Single)
        .gravity(1.0)
        .repulsion_constant(15000.0) // Increased to separate nodes horizontally
        .build();

    println!("Running physics simulation...");
    rendered.run_simulation();
    println!("Converged after {} iterations\n", rendered.iterations());

    let grid = rendered.render_to_grid();
    let (width, height) = grid.size();

    println!("Grid size: {}x{}\n", width, height);

    grid.print();
}

examples/basic.rs (line 25)

fn main() {
    // Create a simple state machine graph
    let mut graph: DiGraph<&str, &str> = DiGraph::new();

    let start = graph.add_node("Start");
    let loading = graph.add_node("Loading");
    let ready = graph.add_node("Ready");
    let error = graph.add_node("Error");
    let done = graph.add_node("Done");

    graph.add_edge(start, loading, "init");
    graph.add_edge(loading, ready, "success");
    graph.add_edge(loading, error, "fail");
    graph.add_edge(ready, done, "complete");
    graph.add_edge(error, loading, "retry");
    graph.add_edge(error, done, "abort");

    // Create rendered graph with custom settings
    let mut rendered = RenderedGraph::builder()
        .graph(graph)
        .border_style(BoxBorder::Rounded)
        .gravity(1.0)
        .build();

    // Run physics simulation
    println!("Running physics simulation...");
    rendered.run_simulation();
    println!("Converged after {} iterations", rendered.iterations());

    // Customize colors
    rendered.set_node_border_color(start, Color::Green);
    rendered.set_node_border_color(error, Color::Red);
    rendered.set_node_text_color(error, Color::Red);
    rendered.set_node_border_color(done, Color::Blue);

    // Render to grid and print
    let grid = rendered.render_to_grid();
    let (width, height) = grid.size();

    println!("\nRendered graph ({}x{}):\n", width, height);

    // Print grid using the built-in print method
    grid.print();
}

examples/tui.rs (line 31)

fn main() -> io::Result<()> {
    // Create a state machine graph
    let mut graph: DiGraph<&str, &str> = DiGraph::new();

    let idle = graph.add_node("Idle");
    let running = graph.add_node("Running");
    let paused = graph.add_node("Paused");
    let complete = graph.add_node("Complete");
    let failed = graph.add_node("Failed");

    let e_start = graph.add_edge(idle, running, "start");
    let e_pause = graph.add_edge(running, paused, "pause");
    let e_resume = graph.add_edge(paused, running, "resume");
    let e_finish = graph.add_edge(running, complete, "finish");
    let e_fail = graph.add_edge(running, failed, "error");
    let e_reset = graph.add_edge(complete, idle, "reset");
    let e_retry = graph.add_edge(failed, idle, "retry");

    // Create rendered graph
    let mut rendered = RenderedGraph::builder()
        .graph(graph)
        .border_style(BoxBorder::Rounded)
        .gravity(0.8)
        .spring_constant(0.05)
        .repulsion_constant(8000.0)
        .build();

    // Run physics simulation
    rendered.run_simulation();

    // Apply colors based on state meaning
    rendered.set_node_border_color(idle, Color::Gray);
    rendered.set_node_border_color(running, Color::Green);
    rendered.set_node_text_color(running, Color::Green);
    rendered.set_node_border_color(paused, Color::Yellow);
    rendered.set_node_text_color(paused, Color::Yellow);
    rendered.set_node_border_color(complete, Color::Blue);
    rendered.set_node_text_color(complete, Color::Blue);
    rendered.set_node_border_color(failed, Color::Red);
    rendered.set_node_text_color(failed, Color::Red);

    // Color edges
    rendered.set_edge_color(e_start, Color::Green);
    rendered.set_edge_color(e_pause, Color::Yellow);
    rendered.set_edge_color(e_resume, Color::Green);
    rendered.set_edge_color(e_finish, Color::Blue);
    rendered.set_edge_color(e_fail, Color::Red);
    rendered.set_edge_color(e_reset, Color::Gray);
    rendered.set_edge_color(e_retry, Color::Yellow);

    // Run TUI
    let mut terminal = ratatui::init();
    let result = run_app(&mut terminal, &mut rendered);
    ratatui::restore();
    result
}

pub fn graph(&self) -> &DiGraph<N, E>

Get a reference to the underlying graph.

pub fn physics_config(&self) -> &PhysicsConfig

Get the physics configuration.

pub fn set_physics_config(&mut self, config: PhysicsConfig)

Set the physics configuration.

pub fn tick(&mut self)

Advance the physics simulation by one step.

pub fn is_stable(&self) -> bool

Check if the simulation has converged.

pub fn run_simulation(&mut self)

Run the physics simulation until stable.

Examples found in repository

examples/circular.rs (line 28)

fn main() {
    // Create a graph with circular edges (T <-> U)
    let mut graph: DiGraph<&str, &str> = DiGraph::new();

    let t = graph.add_node("T: Task");
    let u = graph.add_node("U: User");

    // Bidirectional edges - these would overlap without parallel edge handling
    graph.add_edge(t, u, "question");
    graph.add_edge(u, t, "answer");

    let mut rendered = RenderedGraph::builder()
        .graph(graph)
        .border_style(BoxBorder::Single)
        .gravity(1.0)
        .repulsion_constant(15000.0) // Increased to separate nodes horizontally
        .build();

    println!("Running physics simulation...");
    rendered.run_simulation();
    println!("Converged after {} iterations\n", rendered.iterations());

    let grid = rendered.render_to_grid();
    let (width, height) = grid.size();

    println!("Grid size: {}x{}\n", width, height);

    grid.print();
}

examples/basic.rs (line 33)

fn main() {
    // Create a simple state machine graph
    let mut graph: DiGraph<&str, &str> = DiGraph::new();

    let start = graph.add_node("Start");
    let loading = graph.add_node("Loading");
    let ready = graph.add_node("Ready");
    let error = graph.add_node("Error");
    let done = graph.add_node("Done");

    graph.add_edge(start, loading, "init");
    graph.add_edge(loading, ready, "success");
    graph.add_edge(loading, error, "fail");
    graph.add_edge(ready, done, "complete");
    graph.add_edge(error, loading, "retry");
    graph.add_edge(error, done, "abort");

    // Create rendered graph with custom settings
    let mut rendered = RenderedGraph::builder()
        .graph(graph)
        .border_style(BoxBorder::Rounded)
        .gravity(1.0)
        .build();

    // Run physics simulation
    println!("Running physics simulation...");
    rendered.run_simulation();
    println!("Converged after {} iterations", rendered.iterations());

    // Customize colors
    rendered.set_node_border_color(start, Color::Green);
    rendered.set_node_border_color(error, Color::Red);
    rendered.set_node_text_color(error, Color::Red);
    rendered.set_node_border_color(done, Color::Blue);

    // Render to grid and print
    let grid = rendered.render_to_grid();
    let (width, height) = grid.size();

    println!("\nRendered graph ({}x{}):\n", width, height);

    // Print grid using the built-in print method
    grid.print();
}

examples/tui.rs (line 40)

fn main() -> io::Result<()> {
    // Create a state machine graph
    let mut graph: DiGraph<&str, &str> = DiGraph::new();

    let idle = graph.add_node("Idle");
    let running = graph.add_node("Running");
    let paused = graph.add_node("Paused");
    let complete = graph.add_node("Complete");
    let failed = graph.add_node("Failed");

    let e_start = graph.add_edge(idle, running, "start");
    let e_pause = graph.add_edge(running, paused, "pause");
    let e_resume = graph.add_edge(paused, running, "resume");
    let e_finish = graph.add_edge(running, complete, "finish");
    let e_fail = graph.add_edge(running, failed, "error");
    let e_reset = graph.add_edge(complete, idle, "reset");
    let e_retry = graph.add_edge(failed, idle, "retry");

    // Create rendered graph
    let mut rendered = RenderedGraph::builder()
        .graph(graph)
        .border_style(BoxBorder::Rounded)
        .gravity(0.8)
        .spring_constant(0.05)
        .repulsion_constant(8000.0)
        .build();

    // Run physics simulation
    rendered.run_simulation();

    // Apply colors based on state meaning
    rendered.set_node_border_color(idle, Color::Gray);
    rendered.set_node_border_color(running, Color::Green);
    rendered.set_node_text_color(running, Color::Green);
    rendered.set_node_border_color(paused, Color::Yellow);
    rendered.set_node_text_color(paused, Color::Yellow);
    rendered.set_node_border_color(complete, Color::Blue);
    rendered.set_node_text_color(complete, Color::Blue);
    rendered.set_node_border_color(failed, Color::Red);
    rendered.set_node_text_color(failed, Color::Red);

    // Color edges
    rendered.set_edge_color(e_start, Color::Green);
    rendered.set_edge_color(e_pause, Color::Yellow);
    rendered.set_edge_color(e_resume, Color::Green);
    rendered.set_edge_color(e_finish, Color::Blue);
    rendered.set_edge_color(e_fail, Color::Red);
    rendered.set_edge_color(e_reset, Color::Gray);
    rendered.set_edge_color(e_retry, Color::Yellow);

    // Run TUI
    let mut terminal = ratatui::init();
    let result = run_app(&mut terminal, &mut rendered);
    ratatui::restore();
    result
}

pub fn iterations(&self) -> usize

Get the number of iterations run so far.

Examples found in repository

examples/circular.rs (line 29)

fn main() {
    // Create a graph with circular edges (T <-> U)
    let mut graph: DiGraph<&str, &str> = DiGraph::new();

    let t = graph.add_node("T: Task");
    let u = graph.add_node("U: User");

    // Bidirectional edges - these would overlap without parallel edge handling
    graph.add_edge(t, u, "question");
    graph.add_edge(u, t, "answer");

    let mut rendered = RenderedGraph::builder()
        .graph(graph)
        .border_style(BoxBorder::Single)
        .gravity(1.0)
        .repulsion_constant(15000.0) // Increased to separate nodes horizontally
        .build();

    println!("Running physics simulation...");
    rendered.run_simulation();
    println!("Converged after {} iterations\n", rendered.iterations());

    let grid = rendered.render_to_grid();
    let (width, height) = grid.size();

    println!("Grid size: {}x{}\n", width, height);

    grid.print();
}

examples/basic.rs (line 34)

fn main() {
    // Create a simple state machine graph
    let mut graph: DiGraph<&str, &str> = DiGraph::new();

    let start = graph.add_node("Start");
    let loading = graph.add_node("Loading");
    let ready = graph.add_node("Ready");
    let error = graph.add_node("Error");
    let done = graph.add_node("Done");

    graph.add_edge(start, loading, "init");
    graph.add_edge(loading, ready, "success");
    graph.add_edge(loading, error, "fail");
    graph.add_edge(ready, done, "complete");
    graph.add_edge(error, loading, "retry");
    graph.add_edge(error, done, "abort");

    // Create rendered graph with custom settings
    let mut rendered = RenderedGraph::builder()
        .graph(graph)
        .border_style(BoxBorder::Rounded)
        .gravity(1.0)
        .build();

    // Run physics simulation
    println!("Running physics simulation...");
    rendered.run_simulation();
    println!("Converged after {} iterations", rendered.iterations());

    // Customize colors
    rendered.set_node_border_color(start, Color::Green);
    rendered.set_node_border_color(error, Color::Red);
    rendered.set_node_text_color(error, Color::Red);
    rendered.set_node_border_color(done, Color::Blue);

    // Render to grid and print
    let grid = rendered.render_to_grid();
    let (width, height) = grid.size();

    println!("\nRendered graph ({}x{}):\n", width, height);

    // Print grid using the built-in print method
    grid.print();
}

pub fn set_node_border_color(&mut self, node: NodeIndex, color: Color)

Set the border color of a node.

Examples found in repository

examples/basic.rs (line 37)

fn main() {
    // Create a simple state machine graph
    let mut graph: DiGraph<&str, &str> = DiGraph::new();

    let start = graph.add_node("Start");
    let loading = graph.add_node("Loading");
    let ready = graph.add_node("Ready");
    let error = graph.add_node("Error");
    let done = graph.add_node("Done");

    graph.add_edge(start, loading, "init");
    graph.add_edge(loading, ready, "success");
    graph.add_edge(loading, error, "fail");
    graph.add_edge(ready, done, "complete");
    graph.add_edge(error, loading, "retry");
    graph.add_edge(error, done, "abort");

    // Create rendered graph with custom settings
    let mut rendered = RenderedGraph::builder()
        .graph(graph)
        .border_style(BoxBorder::Rounded)
        .gravity(1.0)
        .build();

    // Run physics simulation
    println!("Running physics simulation...");
    rendered.run_simulation();
    println!("Converged after {} iterations", rendered.iterations());

    // Customize colors
    rendered.set_node_border_color(start, Color::Green);
    rendered.set_node_border_color(error, Color::Red);
    rendered.set_node_text_color(error, Color::Red);
    rendered.set_node_border_color(done, Color::Blue);

    // Render to grid and print
    let grid = rendered.render_to_grid();
    let (width, height) = grid.size();

    println!("\nRendered graph ({}x{}):\n", width, height);

    // Print grid using the built-in print method
    grid.print();
}

examples/tui.rs (line 43)

fn main() -> io::Result<()> {
    // Create a state machine graph
    let mut graph: DiGraph<&str, &str> = DiGraph::new();

    let idle = graph.add_node("Idle");
    let running = graph.add_node("Running");
    let paused = graph.add_node("Paused");
    let complete = graph.add_node("Complete");
    let failed = graph.add_node("Failed");

    let e_start = graph.add_edge(idle, running, "start");
    let e_pause = graph.add_edge(running, paused, "pause");
    let e_resume = graph.add_edge(paused, running, "resume");
    let e_finish = graph.add_edge(running, complete, "finish");
    let e_fail = graph.add_edge(running, failed, "error");
    let e_reset = graph.add_edge(complete, idle, "reset");
    let e_retry = graph.add_edge(failed, idle, "retry");

    // Create rendered graph
    let mut rendered = RenderedGraph::builder()
        .graph(graph)
        .border_style(BoxBorder::Rounded)
        .gravity(0.8)
        .spring_constant(0.05)
        .repulsion_constant(8000.0)
        .build();

    // Run physics simulation
    rendered.run_simulation();

    // Apply colors based on state meaning
    rendered.set_node_border_color(idle, Color::Gray);
    rendered.set_node_border_color(running, Color::Green);
    rendered.set_node_text_color(running, Color::Green);
    rendered.set_node_border_color(paused, Color::Yellow);
    rendered.set_node_text_color(paused, Color::Yellow);
    rendered.set_node_border_color(complete, Color::Blue);
    rendered.set_node_text_color(complete, Color::Blue);
    rendered.set_node_border_color(failed, Color::Red);
    rendered.set_node_text_color(failed, Color::Red);

    // Color edges
    rendered.set_edge_color(e_start, Color::Green);
    rendered.set_edge_color(e_pause, Color::Yellow);
    rendered.set_edge_color(e_resume, Color::Green);
    rendered.set_edge_color(e_finish, Color::Blue);
    rendered.set_edge_color(e_fail, Color::Red);
    rendered.set_edge_color(e_reset, Color::Gray);
    rendered.set_edge_color(e_retry, Color::Yellow);

    // Run TUI
    let mut terminal = ratatui::init();
    let result = run_app(&mut terminal, &mut rendered);
    ratatui::restore();
    result
}

pub fn set_node_text_color(&mut self, node: NodeIndex, color: Color)

Set the text color of a node.

Examples found in repository

examples/basic.rs (line 39)

fn main() {
    // Create a simple state machine graph
    let mut graph: DiGraph<&str, &str> = DiGraph::new();

    let start = graph.add_node("Start");
    let loading = graph.add_node("Loading");
    let ready = graph.add_node("Ready");
    let error = graph.add_node("Error");
    let done = graph.add_node("Done");

    graph.add_edge(start, loading, "init");
    graph.add_edge(loading, ready, "success");
    graph.add_edge(loading, error, "fail");
    graph.add_edge(ready, done, "complete");
    graph.add_edge(error, loading, "retry");
    graph.add_edge(error, done, "abort");

    // Create rendered graph with custom settings
    let mut rendered = RenderedGraph::builder()
        .graph(graph)
        .border_style(BoxBorder::Rounded)
        .gravity(1.0)
        .build();

    // Run physics simulation
    println!("Running physics simulation...");
    rendered.run_simulation();
    println!("Converged after {} iterations", rendered.iterations());

    // Customize colors
    rendered.set_node_border_color(start, Color::Green);
    rendered.set_node_border_color(error, Color::Red);
    rendered.set_node_text_color(error, Color::Red);
    rendered.set_node_border_color(done, Color::Blue);

    // Render to grid and print
    let grid = rendered.render_to_grid();
    let (width, height) = grid.size();

    println!("\nRendered graph ({}x{}):\n", width, height);

    // Print grid using the built-in print method
    grid.print();
}

examples/tui.rs (line 45)

fn main() -> io::Result<()> {
    // Create a state machine graph
    let mut graph: DiGraph<&str, &str> = DiGraph::new();

    let idle = graph.add_node("Idle");
    let running = graph.add_node("Running");
    let paused = graph.add_node("Paused");
    let complete = graph.add_node("Complete");
    let failed = graph.add_node("Failed");

    let e_start = graph.add_edge(idle, running, "start");
    let e_pause = graph.add_edge(running, paused, "pause");
    let e_resume = graph.add_edge(paused, running, "resume");
    let e_finish = graph.add_edge(running, complete, "finish");
    let e_fail = graph.add_edge(running, failed, "error");
    let e_reset = graph.add_edge(complete, idle, "reset");
    let e_retry = graph.add_edge(failed, idle, "retry");

    // Create rendered graph
    let mut rendered = RenderedGraph::builder()
        .graph(graph)
        .border_style(BoxBorder::Rounded)
        .gravity(0.8)
        .spring_constant(0.05)
        .repulsion_constant(8000.0)
        .build();

    // Run physics simulation
    rendered.run_simulation();

    // Apply colors based on state meaning
    rendered.set_node_border_color(idle, Color::Gray);
    rendered.set_node_border_color(running, Color::Green);
    rendered.set_node_text_color(running, Color::Green);
    rendered.set_node_border_color(paused, Color::Yellow);
    rendered.set_node_text_color(paused, Color::Yellow);
    rendered.set_node_border_color(complete, Color::Blue);
    rendered.set_node_text_color(complete, Color::Blue);
    rendered.set_node_border_color(failed, Color::Red);
    rendered.set_node_text_color(failed, Color::Red);

    // Color edges
    rendered.set_edge_color(e_start, Color::Green);
    rendered.set_edge_color(e_pause, Color::Yellow);
    rendered.set_edge_color(e_resume, Color::Green);
    rendered.set_edge_color(e_finish, Color::Blue);
    rendered.set_edge_color(e_fail, Color::Red);
    rendered.set_edge_color(e_reset, Color::Gray);
    rendered.set_edge_color(e_retry, Color::Yellow);

    // Run TUI
    let mut terminal = ratatui::init();
    let result = run_app(&mut terminal, &mut rendered);
    ratatui::restore();
    result
}

pub fn set_node_colors(&mut self, node: NodeIndex, border: Color, text: Color)

Set both border and text color of a node.

pub fn set_edge_color(&mut self, edge: EdgeIndex, color: Color)

Set the line color of an edge.

Examples found in repository

examples/tui.rs (line 54)

fn main() -> io::Result<()> {
    // Create a state machine graph
    let mut graph: DiGraph<&str, &str> = DiGraph::new();

    let idle = graph.add_node("Idle");
    let running = graph.add_node("Running");
    let paused = graph.add_node("Paused");
    let complete = graph.add_node("Complete");
    let failed = graph.add_node("Failed");

    let e_start = graph.add_edge(idle, running, "start");
    let e_pause = graph.add_edge(running, paused, "pause");
    let e_resume = graph.add_edge(paused, running, "resume");
    let e_finish = graph.add_edge(running, complete, "finish");
    let e_fail = graph.add_edge(running, failed, "error");
    let e_reset = graph.add_edge(complete, idle, "reset");
    let e_retry = graph.add_edge(failed, idle, "retry");

    // Create rendered graph
    let mut rendered = RenderedGraph::builder()
        .graph(graph)
        .border_style(BoxBorder::Rounded)
        .gravity(0.8)
        .spring_constant(0.05)
        .repulsion_constant(8000.0)
        .build();

    // Run physics simulation
    rendered.run_simulation();

    // Apply colors based on state meaning
    rendered.set_node_border_color(idle, Color::Gray);
    rendered.set_node_border_color(running, Color::Green);
    rendered.set_node_text_color(running, Color::Green);
    rendered.set_node_border_color(paused, Color::Yellow);
    rendered.set_node_text_color(paused, Color::Yellow);
    rendered.set_node_border_color(complete, Color::Blue);
    rendered.set_node_text_color(complete, Color::Blue);
    rendered.set_node_border_color(failed, Color::Red);
    rendered.set_node_text_color(failed, Color::Red);

    // Color edges
    rendered.set_edge_color(e_start, Color::Green);
    rendered.set_edge_color(e_pause, Color::Yellow);
    rendered.set_edge_color(e_resume, Color::Green);
    rendered.set_edge_color(e_finish, Color::Blue);
    rendered.set_edge_color(e_fail, Color::Red);
    rendered.set_edge_color(e_reset, Color::Gray);
    rendered.set_edge_color(e_retry, Color::Yellow);

    // Run TUI
    let mut terminal = ratatui::init();
    let result = run_app(&mut terminal, &mut rendered);
    ratatui::restore();
    result
}

pub fn set_edge_text_color(&mut self, edge: EdgeIndex, color: Color)

Set the text color of an edge label.

pub fn set_edge_colors(&mut self, edge: EdgeIndex, line: Color, text: Color)

Set both line and text color of an edge.

pub fn set_all_node_border_colors(&mut self, color: Color)

Set border color for all nodes.

pub fn set_all_node_text_colors(&mut self, color: Color)

Set text color for all nodes.

pub fn set_all_edge_colors(&mut self, color: Color)

Set line color for all edges.

pub fn reset_node_styles(&mut self)

Reset all node styles to default.

pub fn reset_edge_styles(&mut self)

Reset all edge styles to default.

pub fn set_default_node_style(&mut self, style: NodeStyle)

Set the default node style (used for new nodes and reset).

pub fn set_default_edge_style(&mut self, style: EdgeStyle)

Set the default edge style.

pub fn set_border_style(&mut self, border: BoxBorder)

Set the box border style for all nodes.

pub fn set_scaling_mode(&mut self, mode: ScalingMode)

Set the scaling mode for handling large graphs.

pub fn auto_scale(&mut self, max_width: usize)

Auto-detect and apply appropriate scaling mode based on terminal width.

pub fn render_to_grid(&mut self) -> CharGrid

Render the graph to a character grid.

Examples found in repository

examples/circular.rs (line 31)

fn main() {
    // Create a graph with circular edges (T <-> U)
    let mut graph: DiGraph<&str, &str> = DiGraph::new();

    let t = graph.add_node("T: Task");
    let u = graph.add_node("U: User");

    // Bidirectional edges - these would overlap without parallel edge handling
    graph.add_edge(t, u, "question");
    graph.add_edge(u, t, "answer");

    let mut rendered = RenderedGraph::builder()
        .graph(graph)
        .border_style(BoxBorder::Single)
        .gravity(1.0)
        .repulsion_constant(15000.0) // Increased to separate nodes horizontally
        .build();

    println!("Running physics simulation...");
    rendered.run_simulation();
    println!("Converged after {} iterations\n", rendered.iterations());

    let grid = rendered.render_to_grid();
    let (width, height) = grid.size();

    println!("Grid size: {}x{}\n", width, height);

    grid.print();
}

examples/basic.rs (line 43)

fn main() {
    // Create a simple state machine graph
    let mut graph: DiGraph<&str, &str> = DiGraph::new();

    let start = graph.add_node("Start");
    let loading = graph.add_node("Loading");
    let ready = graph.add_node("Ready");
    let error = graph.add_node("Error");
    let done = graph.add_node("Done");

    graph.add_edge(start, loading, "init");
    graph.add_edge(loading, ready, "success");
    graph.add_edge(loading, error, "fail");
    graph.add_edge(ready, done, "complete");
    graph.add_edge(error, loading, "retry");
    graph.add_edge(error, done, "abort");

    // Create rendered graph with custom settings
    let mut rendered = RenderedGraph::builder()
        .graph(graph)
        .border_style(BoxBorder::Rounded)
        .gravity(1.0)
        .build();

    // Run physics simulation
    println!("Running physics simulation...");
    rendered.run_simulation();
    println!("Converged after {} iterations", rendered.iterations());

    // Customize colors
    rendered.set_node_border_color(start, Color::Green);
    rendered.set_node_border_color(error, Color::Red);
    rendered.set_node_text_color(error, Color::Red);
    rendered.set_node_border_color(done, Color::Blue);

    // Render to grid and print
    let grid = rendered.render_to_grid();
    let (width, height) = grid.size();

    println!("\nRendered graph ({}x{}):\n", width, height);

    // Print grid using the built-in print method
    grid.print();
}

pub fn widget(&mut self) -> GraphWidget<'_, N, E>

Create a widget for rendering with ratatui.

Examples found in repository

examples/tui.rs (line 80)

fn run_app<N, E>(
    terminal: &mut DefaultTerminal,
    rendered: &mut RenderedGraph<N, E>,
) -> io::Result<()>
where
    N: std::fmt::Display + Clone,
    E: std::fmt::Display + Clone,
{
    loop {
        terminal.draw(|frame| {
            let area = frame.area();
            frame.render_widget(rendered.widget(), area);
        })?;

        if let Event::Key(key) = event::read()? {
            if key.code == KeyCode::Char('q') || key.code == KeyCode::Esc {
                break;
            }
        }
    }
    Ok(())
}