Struct ImageView 

pub struct ImageView { /* private fields */ }

Image view.

Works on terminals that support the Kitty graphics protocol

The view supports shrink, fit, and scale sizing modes (shrink is the default), image alignment, and scrolling.

Implementations

impl ImageView

pub fn image(&self) -> Option<&Image>

Image.

pub fn set_image(&mut self, image: Image)

Set image.

Examples found in repository

examples/pdf.rs (line 77)

fn set_page(cursive: &mut Cursive, index: usize) {
    let image = {
        let pages: &mut Pages = cursive.user_data().unwrap();
        pages.index = index;
        pages.images[index].take().unwrap()
    };
    cursive.call_on_name(NAME, |image_view: &mut ImageView| image_view.set_image(image));
}

pub fn take_image(&mut self) -> Option<Image>

Take image.

Examples found in repository

examples/pdf.rs (line 81)

fn unset_page(cursive: &mut Cursive) {
    let image = cursive.call_on_name(NAME, |image_view: &mut ImageView| image_view.take_image()).unwrap();
    if let Some(image) = image {
        let pages: &mut Pages = cursive.user_data().unwrap();
        pages.images[pages.index] = Some(image);
    }
}

pub fn with_image(self, image: Image) -> Self

Set image.

Chainable.

Examples found in repository

examples/gif.rs (lines 11-14)

fn main() {
    let mut cursive = default();

    cursive.add_layer(Panel::new(ImageView::default().with_image(
        // GIFs will always be RGBA
        Image::new_stream_from_gif_file(FILE).expect("new_stream_from_gif_file"),
    )));

    cursive.add_global_callback('q', |cursive| cursive.quit());

    cursive.run();
}

examples/simple.rs (lines 14-19)

fn main() {
    let mut cursive = default();

    // By default the image view uses "shrink" sizing

    cursive.add_layer(Panel::new(ImageView::default().with_image(Image::new_file(
        FILE,
        false,
        ImageFormat::PNG,
        (96, 96),
    ))));

    cursive.add_global_callback('q', |cursive| cursive.quit());

    cursive.run();
}

examples/svg.rs (lines 12-16)

fn main() {
    let mut cursive = default();

    cursive.add_layer(Panel::new(ImageView::default().with_image(
        // SVG can be either PNG or RGBA (PNG is usually more efficient)
        // Note that we can apply scaling during rendering
        Image::new_stream_from_svg_file(FILE, ImageFormat::PNG, 2.5).expect("new_stream_from_svg_file"),
    )));

    cursive.add_global_callback('q', |cursive| cursive.quit());

    cursive.run();
}

examples/scrollable.rs (lines 18-23)

fn main() {
    let mut cursive = default();

    cursive.add_layer(
        Panel::new(
            ImageView::default()
                .with_image(
                    // Note that RGBA is supported, too, if you need transparency
                    Image::new_stream_from_jpeg_file(FILE, ImageFormat::RGB).expect("new_stream_from_jpeg_file"),
                    // If you prefer to keep the image data in memory:
                    // Image::new_owned_from_jpeg_file(FILE, ImageFormat::RGB, true).expect("new_owned_from_jpeg_file"),
                )
                .with_sizing(Sizing::original())
                .scrollable()
                .scroll_x(true),
        )
        .fixed_size((50, 20)),
    );

    cursive.add_global_callback('q', |cursive| cursive.quit());

    cursive.run();
}

examples/positioning.rs (line 22)

fn main() {
    let mut cursive = default();

    cursive.add_layer(Panel::new(
        ImageView::default()
            // We're also showing the use of new_png_file(), which discovers the image size for us
            // (requires the "png" feature)
            .with_image(Image::new_png_file(FILE).expect("new_png_file"))
            .with_name(NAME)
            .fixed_size((50, 20)),
    ));

    cursive.add_global_callback('s', |cursive| {
        _ = cursive.call_on_name(NAME, |image_view: &mut ImageView| {
            image_view.set_sizing(match image_view.sizing() {
                Sizing::Shrink => Sizing::Fit,
                Sizing::Fit => Sizing::Scale(3.),
                Sizing::Scale(_) => Sizing::Shrink,
            })
        });
    });

    cursive.add_global_callback('h', |cursive| {
        _ = cursive.call_on_name(NAME, |image_view: &mut ImageView| {
            image_view.set_align(match image_view.align() {
                Align { h: HAlign::Left, v } => Align { h: HAlign::Center, v },
                Align { h: HAlign::Center, v } => Align { h: HAlign::Right, v },
                Align { h: HAlign::Right, v } => Align { h: HAlign::Left, v },
            })
        });
    });

    cursive.add_global_callback('v', |cursive| {
        _ = cursive.call_on_name(NAME, |image_view: &mut ImageView| {
            image_view.set_align(match image_view.align() {
                Align { h, v: VAlign::Top } => Align { h, v: VAlign::Center },
                Align { h, v: VAlign::Center } => Align { h, v: VAlign::Bottom },
                Align { h, v: VAlign::Bottom } => Align { h, v: VAlign::Top },
            })
        });
    });

    cursive.add_global_callback('q', |cursive| cursive.quit());

    cursive.run();
}

pub fn sizing(&self) -> Sizing

Sizing.

Examples found in repository

examples/positioning.rs (line 29)

fn main() {
    let mut cursive = default();

    cursive.add_layer(Panel::new(
        ImageView::default()
            // We're also showing the use of new_png_file(), which discovers the image size for us
            // (requires the "png" feature)
            .with_image(Image::new_png_file(FILE).expect("new_png_file"))
            .with_name(NAME)
            .fixed_size((50, 20)),
    ));

    cursive.add_global_callback('s', |cursive| {
        _ = cursive.call_on_name(NAME, |image_view: &mut ImageView| {
            image_view.set_sizing(match image_view.sizing() {
                Sizing::Shrink => Sizing::Fit,
                Sizing::Fit => Sizing::Scale(3.),
                Sizing::Scale(_) => Sizing::Shrink,
            })
        });
    });

    cursive.add_global_callback('h', |cursive| {
        _ = cursive.call_on_name(NAME, |image_view: &mut ImageView| {
            image_view.set_align(match image_view.align() {
                Align { h: HAlign::Left, v } => Align { h: HAlign::Center, v },
                Align { h: HAlign::Center, v } => Align { h: HAlign::Right, v },
                Align { h: HAlign::Right, v } => Align { h: HAlign::Left, v },
            })
        });
    });

    cursive.add_global_callback('v', |cursive| {
        _ = cursive.call_on_name(NAME, |image_view: &mut ImageView| {
            image_view.set_align(match image_view.align() {
                Align { h, v: VAlign::Top } => Align { h, v: VAlign::Center },
                Align { h, v: VAlign::Center } => Align { h, v: VAlign::Bottom },
                Align { h, v: VAlign::Bottom } => Align { h, v: VAlign::Top },
            })
        });
    });

    cursive.add_global_callback('q', |cursive| cursive.quit());

    cursive.run();
}

pub fn set_sizing(&mut self, sizing: Sizing)

Set sizing.

Examples found in repository

examples/positioning.rs (lines 29-33)

fn main() {
    let mut cursive = default();

    cursive.add_layer(Panel::new(
        ImageView::default()
            // We're also showing the use of new_png_file(), which discovers the image size for us
            // (requires the "png" feature)
            .with_image(Image::new_png_file(FILE).expect("new_png_file"))
            .with_name(NAME)
            .fixed_size((50, 20)),
    ));

    cursive.add_global_callback('s', |cursive| {
        _ = cursive.call_on_name(NAME, |image_view: &mut ImageView| {
            image_view.set_sizing(match image_view.sizing() {
                Sizing::Shrink => Sizing::Fit,
                Sizing::Fit => Sizing::Scale(3.),
                Sizing::Scale(_) => Sizing::Shrink,
            })
        });
    });

    cursive.add_global_callback('h', |cursive| {
        _ = cursive.call_on_name(NAME, |image_view: &mut ImageView| {
            image_view.set_align(match image_view.align() {
                Align { h: HAlign::Left, v } => Align { h: HAlign::Center, v },
                Align { h: HAlign::Center, v } => Align { h: HAlign::Right, v },
                Align { h: HAlign::Right, v } => Align { h: HAlign::Left, v },
            })
        });
    });

    cursive.add_global_callback('v', |cursive| {
        _ = cursive.call_on_name(NAME, |image_view: &mut ImageView| {
            image_view.set_align(match image_view.align() {
                Align { h, v: VAlign::Top } => Align { h, v: VAlign::Center },
                Align { h, v: VAlign::Center } => Align { h, v: VAlign::Bottom },
                Align { h, v: VAlign::Bottom } => Align { h, v: VAlign::Top },
            })
        });
    });

    cursive.add_global_callback('q', |cursive| cursive.quit());

    cursive.run();
}

pub fn with_sizing(self, sizing: Sizing) -> Self

Set sizing.

Chainable.

Examples found in repository

examples/scrollable.rs (line 24)

fn main() {
    let mut cursive = default();

    cursive.add_layer(
        Panel::new(
            ImageView::default()
                .with_image(
                    // Note that RGBA is supported, too, if you need transparency
                    Image::new_stream_from_jpeg_file(FILE, ImageFormat::RGB).expect("new_stream_from_jpeg_file"),
                    // If you prefer to keep the image data in memory:
                    // Image::new_owned_from_jpeg_file(FILE, ImageFormat::RGB, true).expect("new_owned_from_jpeg_file"),
                )
                .with_sizing(Sizing::original())
                .scrollable()
                .scroll_x(true),
        )
        .fixed_size((50, 20)),
    );

    cursive.add_global_callback('q', |cursive| cursive.quit());

    cursive.run();
}

examples/pdf.rs (line 23)

fn main() {
    let mut cursive = default();

    // The constructor returns a vector of images, one for each page in the PDF
    // PDF pages can be either PNG or RGBA (PNG is usually more efficient)
    // Note that we can apply scaling during rendering
    let images = Image::new_owned_from_pdf_file(FILE, ImageFormat::PNG, 3., false).expect("new_owned_from_pdf_file");

    cursive.set_user_data(Pages::new(images));

    cursive.add_layer(
        Dialog::around(
            Panel::new(
                ImageView::default().with_sizing(Sizing::original()).with_name(NAME).scrollable().scroll_x(true),
            )
            .fixed_size((50, 30)),
        )
        .button("Previous", |cursive| flip_page(cursive, -1))
        .button("Next", |cursive| flip_page(cursive, 1)),
    );

    select_page(&mut cursive, 0);

    cursive.add_global_callback('q', |cursive| cursive.quit());

    cursive.run();
}

pub fn align(&self) -> Align

Align.

Examples found in repository

examples/positioning.rs (line 39)

fn main() {
    let mut cursive = default();

    cursive.add_layer(Panel::new(
        ImageView::default()
            // We're also showing the use of new_png_file(), which discovers the image size for us
            // (requires the "png" feature)
            .with_image(Image::new_png_file(FILE).expect("new_png_file"))
            .with_name(NAME)
            .fixed_size((50, 20)),
    ));

    cursive.add_global_callback('s', |cursive| {
        _ = cursive.call_on_name(NAME, |image_view: &mut ImageView| {
            image_view.set_sizing(match image_view.sizing() {
                Sizing::Shrink => Sizing::Fit,
                Sizing::Fit => Sizing::Scale(3.),
                Sizing::Scale(_) => Sizing::Shrink,
            })
        });
    });

    cursive.add_global_callback('h', |cursive| {
        _ = cursive.call_on_name(NAME, |image_view: &mut ImageView| {
            image_view.set_align(match image_view.align() {
                Align { h: HAlign::Left, v } => Align { h: HAlign::Center, v },
                Align { h: HAlign::Center, v } => Align { h: HAlign::Right, v },
                Align { h: HAlign::Right, v } => Align { h: HAlign::Left, v },
            })
        });
    });

    cursive.add_global_callback('v', |cursive| {
        _ = cursive.call_on_name(NAME, |image_view: &mut ImageView| {
            image_view.set_align(match image_view.align() {
                Align { h, v: VAlign::Top } => Align { h, v: VAlign::Center },
                Align { h, v: VAlign::Center } => Align { h, v: VAlign::Bottom },
                Align { h, v: VAlign::Bottom } => Align { h, v: VAlign::Top },
            })
        });
    });

    cursive.add_global_callback('q', |cursive| cursive.quit());

    cursive.run();
}

pub fn set_align(&mut self, align: Align)

Set align.

Examples found in repository

examples/positioning.rs (lines 39-43)

fn main() {
    let mut cursive = default();

    cursive.add_layer(Panel::new(
        ImageView::default()
            // We're also showing the use of new_png_file(), which discovers the image size for us
            // (requires the "png" feature)
            .with_image(Image::new_png_file(FILE).expect("new_png_file"))
            .with_name(NAME)
            .fixed_size((50, 20)),
    ));

    cursive.add_global_callback('s', |cursive| {
        _ = cursive.call_on_name(NAME, |image_view: &mut ImageView| {
            image_view.set_sizing(match image_view.sizing() {
                Sizing::Shrink => Sizing::Fit,
                Sizing::Fit => Sizing::Scale(3.),
                Sizing::Scale(_) => Sizing::Shrink,
            })
        });
    });

    cursive.add_global_callback('h', |cursive| {
        _ = cursive.call_on_name(NAME, |image_view: &mut ImageView| {
            image_view.set_align(match image_view.align() {
                Align { h: HAlign::Left, v } => Align { h: HAlign::Center, v },
                Align { h: HAlign::Center, v } => Align { h: HAlign::Right, v },
                Align { h: HAlign::Right, v } => Align { h: HAlign::Left, v },
            })
        });
    });

    cursive.add_global_callback('v', |cursive| {
        _ = cursive.call_on_name(NAME, |image_view: &mut ImageView| {
            image_view.set_align(match image_view.align() {
                Align { h, v: VAlign::Top } => Align { h, v: VAlign::Center },
                Align { h, v: VAlign::Center } => Align { h, v: VAlign::Bottom },
                Align { h, v: VAlign::Bottom } => Align { h, v: VAlign::Top },
            })
        });
    });

    cursive.add_global_callback('q', |cursive| cursive.quit());

    cursive.run();
}

pub fn with_align(self, align: Align) -> Self

Set align.

Chainable.

Trait Implementations

impl Default for ImageView

fn default() -> Self

Returns the “default value” for a type.

impl View for ImageView

fn type_name(&self) -> &'static str

Returns the type of this view.

fn required_size(&mut self, constraint: Vec2) -> Vec2

Returns the minimum size the view requires with the given restrictions.

fn needs_relayout(&self) -> bool

Should return true if the view content changed since the last call to layout().

fn layout(&mut self, size: Vec2)

Called once the size for this view has been decided.

fn draw(&self, printer: &Printer<'_, '_>)

Draws the view with the given printer (includes bounds) and focus.

fn on_event(&mut self, _: Event) -> EventResult

Called when an event is received (key press, mouse event, …).

fn call_on_any( &mut self, _: &Selector<'_>, _: &mut dyn FnMut(&mut (dyn View + 'static)), )

Runs a closure on the view identified by the given selector.

fn focus_view(&mut self, _: &Selector<'_>) -> Result<EventResult, ViewNotFound>

Moves the focus to the view identified by the given selector.

fn take_focus(&mut self, source: Direction) -> Result<EventResult, CannotFocus>

Attempt to give this view the focus.

fn important_area(&self, view_size: XY<usize>) -> Rect

What part of the view is important and should be visible?