Struct i_slint_core::graphics::Image
source · [−]#[repr(transparent)]pub struct Image(_);
Expand description
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
sourceimpl Image
impl Image
sourcepub fn load_from_path(path: &Path) -> Result<Self, LoadImageError>
pub fn load_from_path(path: &Path) -> Result<Self, LoadImageError>
Load an Image from a path to a file containing an image
sourcepub fn from_rgb8(buffer: SharedPixelBuffer<Rgb8Pixel>) -> Self
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.
sourcepub fn from_rgba8(buffer: SharedPixelBuffer<Rgba8Pixel>) -> Self
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.
sourcepub fn from_rgba8_premultiplied(buffer: SharedPixelBuffer<Rgba8Pixel>) -> Self
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.
sourcepub fn path(&self) -> Option<&Path>
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
sourceimpl<'a> From<&'a Image> for &'a ImageInner
impl<'a> From<&'a Image> for &'a ImageInner
sourceimpl From<ImageInner> for Image
impl From<ImageInner> for Image
sourcefn from(original: ImageInner) -> Image
fn from(original: ImageInner) -> Image
Converts to this type from the input type.
impl StructuralPartialEq for Image
Auto Trait Implementations
impl RefUnwindSafe for Image
impl Send for Image
impl !Sync for Image
impl Unpin for Image
impl UnwindSafe for Image
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more