Struct i_slint_core::graphics::Image

#[repr(transparent)]
pub struct Image(_);

An image type that can be displayed by the Image element. You can construct Image objects from a path to an image file on disk, using Self::load_from_path.

Another typical use-case is to render the image content with Rust code. For this it’s most efficient to create a new SharedPixelBuffer with the known dimensions and pass the mutable slice to your rendering function. Afterwards you can create an Image.

The following example creates a 320x200 RGB pixel buffer and calls an external low_level_render() function to draw a shape into it. Finally the result is stored in an Image with Self::from_rgb8():

fn low_level_render(width: u32, height: u32, buffer: &mut [u8]) {
    // render beautiful circle or other shapes here
}

let mut pixel_buffer = SharedPixelBuffer::<Rgb8Pixel>::new(320, 200);

low_level_render(pixel_buffer.width(), pixel_buffer.height(),
                 pixel_buffer.make_mut_bytes());

let image = Image::from_rgb8(pixel_buffer);

Another use-case is to import existing image data into Slint, by creating a new Image through cloning of another image type.

The following example uses the popular image crate to load a .png file from disk, apply brightening filter on it and then import it into an Image:

let mut cat_image = image::open("cat.png").expect("Error loading cat image").into_rgba8();

image::imageops::colorops::brighten_in_place(&mut cat_image, 20);

let buffer = SharedPixelBuffer::<Rgba8Pixel>::clone_from_slice(
    cat_image.as_raw(),
    cat_image.width(),
    cat_image.height(),
);
let image = Image::from_rgba8(buffer);

A popular software (CPU) rendering library in Rust is tiny-skia. The following example shows how to use tiny-skia to render into a SharedPixelBuffer:

let mut pixel_buffer = SharedPixelBuffer::<Rgba8Pixel>::new(640, 480);
let width = pixel_buffer.width();
let height = pixel_buffer.height();
let mut pixmap = tiny_skia::PixmapMut::from_bytes(
    pixel_buffer.make_mut_bytes(), width, height
).unwrap();
pixmap.fill(tiny_skia::Color::TRANSPARENT);

let circle = tiny_skia::PathBuilder::from_circle(320., 240., 150.).unwrap();

let mut paint = tiny_skia::Paint::default();
paint.shader = tiny_skia::LinearGradient::new(
    tiny_skia::Point::from_xy(100.0, 100.0),
    tiny_skia::Point::from_xy(400.0, 400.0),
    vec![
        tiny_skia::GradientStop::new(0.0, tiny_skia::Color::from_rgba8(50, 127, 150, 200)),
        tiny_skia::GradientStop::new(1.0, tiny_skia::Color::from_rgba8(220, 140, 75, 180)),
    ],
    tiny_skia::SpreadMode::Pad,
    tiny_skia::Transform::identity(),
).unwrap();

pixmap.fill_path(&circle, &paint, tiny_skia::FillRule::Winding, Default::default(), None);

let image = Image::from_rgba8_premultiplied(pixel_buffer);

Implementations

impl Image

pub fn load_from_path(path: &Path) -> Result<Self, LoadImageError>

Load an Image from a path to a file containing an image

pub fn from_rgb8(buffer: SharedPixelBuffer<Rgb8Pixel>) -> Self

Creates a new Image from the specified shared pixel buffer, where each pixel has three color channels (red, green and blue) encoded as u8.

pub fn from_rgba8(buffer: SharedPixelBuffer<Rgba8Pixel>) -> Self

Creates a new Image from the specified shared pixel buffer, where each pixel has four color channels (red, green, blue and alpha) encoded as u8.

pub fn from_rgba8_premultiplied(buffer: SharedPixelBuffer<Rgba8Pixel>) -> Self

Creates a new Image from the specified shared pixel buffer, where each pixel has four color channels (red, green, blue and alpha) encoded as u8 and, in contrast to Self::from_rgba8, the alpha channel is also assumed to be multiplied to the red, green and blue channels.

Only construct an Image with this function if you know that your pixels are encoded this way.

pub fn size(&self) -> IntSize

Returns the size of the Image in pixels.

pub fn path(&self) -> Option<&Path>

Returns the path of the image on disk, if it was constructed via Self::load_from_path.

For example:

let path_buf = Path::new(env!("CARGO_MANIFEST_DIR"))
    .join("../../examples/printerdemo/ui/images/cat.jpg");
let image = Image::load_from_path(&path_buf).unwrap();
assert_eq!(image.path(), Some(path_buf.as_path()));

Trait Implementations

impl Clone for Image

fn clone(&self) -> Image

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Image

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

Formats the value using the given formatter.

impl Default for Image

fn default() -> Image

Returns the “default value” for a type.

impl<'a> From<&'a Image> for &'a ImageInner

fn from(other: &'a Image) -> Self

Converts to this type from the input type.

impl From<ImageInner> for Image

fn from(original: ImageInner) -> Image

Converts to this type from the input type.

impl PartialEq<Image> for Image

fn eq(&self, other: &Image) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Image