Struct Image 

pub struct Image<'a> { /* private fields */ }

Fixed size image widget that uses Protocol.

The widget does not react to area resizes. Its advantage lies in that the Protocol needs only one initial resize.

struct App {
    image_static: Protocol,
}
fn ui(f: &mut Frame<'_>, app: &mut App) {
    let image = Image::new(&mut app.image_static);
    f.render_widget(image, f.size());
}

Implementations

impl<'a> Image<'a>

pub fn new(image: &'a Protocol) -> Self

Examples found in repository

examples/demo/main.rs (line 262)

fn ui(f: &mut Frame<'_>, app: &mut App) {
    let outer_block = Block::default()
        .borders(Borders::TOP)
        .title(app.title.as_str());

    let chunks = Layout::default()
        .direction(Direction::Horizontal)
        .constraints([
            Constraint::Percentage(app.split_percent),
            Constraint::Percentage(100 - app.split_percent),
        ])
        .split(outer_block.inner(f.area()));
    f.render_widget(outer_block, f.area());

    let left_chunks = vertical_layout().split(chunks[0]);
    let right_chunks = vertical_layout().split(chunks[1]);

    let block_left_top = block("Fixed");
    let area = block_left_top.inner(left_chunks[0]);
    f.render_widget(
        paragraph(app.background.as_str()).style(Color::Yellow),
        area,
    );
    f.render_widget(block_left_top, left_chunks[0]);
    match app.show_images {
        ShowImages::Resized => {}
        _ => {
            let image = Image::new(&app.image_static);
            // Let it be surrounded by styled text.
            let offset_area = Rect {
                x: area.x + 1,
                y: area.y + 1,
                width: area.width.saturating_sub(2),
                height: area.height.saturating_sub(2),
            };
            f.render_widget(image, offset_area);
        }
    }

    let chunks_left_bottom = Layout::default()
        .direction(Direction::Horizontal)
        .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
        .split(left_chunks[1]);

    app.render_resized_image(f, Resize::Crop(None), chunks_left_bottom[0]);
    app.render_resized_image(f, Resize::Scale(None), chunks_left_bottom[1]);
    app.render_resized_image(f, Resize::Fit(None), right_chunks[0]);

    let block_right_bottom = block("Help");
    let area = block_right_bottom.inner(right_chunks[1]);
    f.render_widget(
        paragraph(vec![
            Line::from("Key bindings:"),
            Line::from(vec![
                Span::from("H").green(),
                Span::from("/"),
                Span::from("L").green(),
                Span::from(": resize"),
            ]),
            Line::from(vec![Span::from("o").green(), Span::from(": cycle image")]),
            Line::from(vec![
                Span::from("t").green(),
                Span::from(format!(": toggle ({:?})", app.show_images)),
            ]),
            Line::from(format!("Font size: {:?}", app.picker.font_size())),
            Line::from(format!("Protocol: {:?}", app.picker.protocol_type())),
        ]),
        area,
    );
    f.render_widget(block_right_bottom, right_chunks[1]);
}

Trait Implementations

impl Widget for Image<'_>

fn render(self, area: Rect, buf: &mut Buffer)

Draws the current state of the widget in the given buffer. That is the only method required to implement a custom widget.