Struct jumpy::prelude::egui::widgets::Image

pub struct Image<'a> {
    source: ImageSource<'a>,
    texture_options: TextureOptions,
    image_options: ImageOptions,
    sense: Sense,
    size: ImageSize,
    pub(crate) show_loading_spinner: Option<bool>,
}

A widget which displays an image.

The task of actually loading the image is deferred to when the Image is added to the Ui, and how it is loaded depends on the provided ImageSource:

• ImageSource::Uri will load the image using the asynchronous loading process.
• ImageSource::Bytes will also load the image using the asynchronous loading process, but with lower latency.
• ImageSource::Texture will use the provided texture.

See load for more information.

Examples

// Using it in a layout:

ui.add(
    egui::Image::new(egui::include_image!("../../assets/ferris.png"))
        .rounding(5.0)
);

// Using it just to paint:

egui::Image::new(egui::include_image!("../../assets/ferris.png"))
    .rounding(5.0)
    .tint(egui::Color32::LIGHT_BLUE)
    .paint_at(ui, rect);

Fields

source: ImageSource<'a>

texture_options: TextureOptions

image_options: ImageOptions

sense: Sense

size: ImageSize

show_loading_spinner: Option<bool>

Implementations

impl<'a> Image<'a>

pub fn new(source: impl Into<ImageSource<'a>>) -> Image<'a>

Load the image from some source.

pub fn from_uri(uri: impl Into<Cow<'a, str>>) -> Image<'a>

Load the image from a URI.

See ImageSource::Uri.

pub fn from_texture(texture: impl Into<SizedTexture>) -> Image<'a>

Load the image from an existing texture.

See ImageSource::Texture.

pub fn from_bytes( uri: impl Into<Cow<'static, str>>, bytes: impl Into<Bytes>, ) -> Image<'a>

Load the image from some raw bytes.

For better error messages, use the bytes:// prefix for the URI.

See ImageSource::Bytes.

pub fn texture_options(self, texture_options: TextureOptions) -> Image<'a>

Texture options used when creating the texture.

pub fn max_width(self, width: f32) -> Image<'a>

Set the max width of the image.

No matter what the image is scaled to, it will never exceed this limit.

pub fn max_height(self, height: f32) -> Image<'a>

Set the max height of the image.

No matter what the image is scaled to, it will never exceed this limit.

pub fn max_size(self, size: Vec2) -> Image<'a>

Set the max size of the image.

No matter what the image is scaled to, it will never exceed this limit.

pub fn maintain_aspect_ratio(self, value: bool) -> Image<'a>

Whether or not the ImageFit should maintain the image’s original aspect ratio.

pub fn fit_to_original_size(self, scale: f32) -> Image<'a>

Fit the image to its original size with some scaling.

This will cause the image to overflow if it is larger than the available space.

If Image::max_size is set, this is guaranteed to never exceed that limit.

pub fn fit_to_exact_size(self, size: Vec2) -> Image<'a>

Fit the image to an exact size.

If Image::max_size is set, this is guaranteed to never exceed that limit.

pub fn fit_to_fraction(self, fraction: Vec2) -> Image<'a>

Fit the image to a fraction of the available space.

If Image::max_size is set, this is guaranteed to never exceed that limit.

pub fn shrink_to_fit(self) -> Image<'a>

Fit the image to 100% of its available size, shrinking it if necessary.

This is a shorthand for Image::fit_to_fraction with 1.0 for both width and height.

If Image::max_size is set, this is guaranteed to never exceed that limit.

pub fn sense(self, sense: Sense) -> Image<'a>

Make the image respond to clicks and/or drags.

pub fn uv(self, uv: impl Into<Rect>) -> Image<'a>

Select UV range. Default is (0,0) in top-left, (1,1) bottom right.

pub fn bg_fill(self, bg_fill: impl Into<Color32>) -> Image<'a>

A solid color to put behind the image. Useful for transparent images.

pub fn tint(self, tint: impl Into<Color32>) -> Image<'a>

Multiply image color with this. Default is WHITE (no tint).

pub fn rotate(self, angle: f32, origin: Vec2) -> Image<'a>

Rotate the image about an origin by some angle

Positive angle is clockwise. Origin is a vector in normalized UV space ((0,0) in top-left, (1,1) bottom right).

To rotate about the center you can pass Vec2::splat(0.5) as the origin.

Due to limitations in the current implementation, this will turn off rounding of the image.

pub fn rounding(self, rounding: impl Into<Rounding>) -> Image<'a>

Round the corners of the image.

The default is no rounding (Rounding::ZERO).

Due to limitations in the current implementation, this will turn off any rotation of the image.

pub fn show_loading_spinner(self, show: bool) -> Image<'a>

Show a spinner when the image is loading.

By default this uses the value of Visuals::image_loading_spinners.

impl<'a> Image<'a>

pub fn calc_size( &self, available_size: Vec2, original_image_size: Option<Vec2>, ) -> Vec2

Returns the size the image will occupy in the final UI.

pub fn load_and_calc_size( &self, ui: &mut Ui, available_size: Vec2, ) -> Option<Vec2>

pub fn size(&self) -> Option<Vec2>

pub fn image_options(&self) -> &ImageOptions

pub fn source(&self) -> &ImageSource<'a>

pub fn load_for_size( &self, ctx: &Context, available_size: Vec2, ) -> Result<TexturePoll, LoadError>

Load the image from its Image::source, returning the resulting SizedTexture.

The available_size is used as a hint when e.g. rendering an svg.

Errors

May fail if they underlying Context::try_load_texture call fails.

pub fn paint_at(&self, ui: &mut Ui, rect: Rect)

Paint the image in the given rectangle.

egui::Image::new(egui::include_image!("../../assets/ferris.png"))
    .rounding(5.0)
    .tint(egui::Color32::LIGHT_BLUE)
    .paint_at(ui, rect);

Trait Implementations

impl<'a> Clone for Image<'a>

fn clone(&self) -> Image<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Image<'a>

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

Formats the value using the given formatter.

impl<'a, T> From<T> for Image<'a>

where T: Into<ImageSource<'a>>,

fn from(value: T) -> Image<'a>

Converts to this type from the input type.

impl<'a> Widget for Image<'a>

fn ui(self, ui: &mut Ui) -> Response

Allocate space, interact, paint, and return a Response.