Struct IMAGES 

pub struct IMAGES;

Image loading, cache and render service.

If the app is running without a VIEW_PROCESS all images are dummy, see load_in_headless for details.

Implementations

impl IMAGES

pub fn load_in_headless(&self) -> Var<bool>

If should still download/read image bytes in headless/renderless mode.

When an app is in headless mode without renderer no VIEW_PROCESS is available, so images cannot be decoded, in this case all images are dummy loading and no attempt to download/read the image files is made. You can enable loading in headless tests to detect IO errors, in this case if there is an error acquiring the image file the image will be a dummy with error.

pub fn limits(&self) -> Var<ImageLimits>

Default loading and decoding limits for each image.

pub fn read(&self, path: impl Into<PathBuf>) -> ImageVar

Request an image, reads from a path and caches it.

This is shorthand for calling IMAGES.image with ImageSource::Read and ImageOptions::cache.

pub fn download<U>(&self, uri: U, accept: Option<Txt>) -> ImageVar

where U: TryInto<Uri>, <U as TryInto<Uri>>::Error: ToTxt,

Request an image, downloads from an uri and caches it.

Optionally define the HTTP ACCEPT header, if not set all image formats supported by the view-process backend are accepted.

This is shorthand for calling IMAGES.image with ImageSource::Download and ImageOptions::cache.

pub fn from_static( &self, data: &'static [u8], format: impl Into<ImageDataFormat>, ) -> ImageVar

Request an image from &'static [u8] data.

The data can be any of the formats described in ImageDataFormat.

This is shorthand for calling IMAGES.image with ImageSource::Data and ImageOptions::cache.

Examples

Get an image from a PNG file embedded in the app executable using include_bytes!.

let image_var = IMAGES.from_static(include_bytes!("ico.png"), "png");

pub fn from_data( &self, data: IpcBytes, format: impl Into<ImageDataFormat>, ) -> ImageVar

Get a cached image from shared data.

The data can be any of the formats described in ImageDataFormat.

This is shorthand for calling IMAGES.image with ImageSource::Data and ImageOptions::cache.

pub fn image( &self, source: impl Into<ImageSource>, options: ImageOptions, limits: Option<ImageLimits>, ) -> ImageVar

Request an image, with full load and cache configuration.

If limits is None the IMAGES.limits is used.

Always returns a loading image due to the deferred nature of services. If the image is already in cache it will be set and bound to it once the current update finishes.

pub fn image_task<F>( &self, source: impl IntoFuture<IntoFuture = F>, options: ImageOptions, limits: Option<ImageLimits>, ) -> ImageVar

where F: Future<Output = ImageSource> + Send + 'static,

Await for an image source, then get or load the image.

If limits is None the IMAGES.limits is used.

This method returns immediately with a loading ImageVar, when source is ready it is used to get the actual ImageVar and binds it to the returned image.

Note that the cache_mode always applies to the inner image, and only to the return image if cache_key is set.

pub fn register( &self, key: Option<ImageHash>, image: (ViewImageHandle, ImageDecoded), ) -> ImageVar

Associate the image produced by direct interaction with the view-process with the key in the cache.

Returns an image var that tracks the image, note that if the key is already known does not use the image data.

Note that you can register entries in ImageEntry::insert_entry, this method is only for tracking a new entry.

Note that the image will not automatically restore on respawn if the view-process fails while decoding.

pub fn clean(&self, key: ImageHash)

Remove the image from the cache, if it is only held by the cache.

You can use ImageSource::hash128_read and ImageSource::hash128_download to get the key for files or downloads.

pub fn purge(&self, key: ImageHash)

Remove the image from the cache, even if it is still referenced outside of the cache.

You can use ImageSource::hash128_read and ImageSource::hash128_download to get the key for files or downloads.

pub fn cache_key(&self, image: &ImageEntry) -> Option<ImageHash>

Gets the cache key of an image.

pub fn is_cached(&self, image: &ImageEntry) -> bool

If the image is cached.

pub fn clean_all(&self)

Clear cached images that are not referenced outside of the cache.

pub fn purge_all(&self)

Clear all cached images, including images that are still referenced outside of the cache.

Image memory only drops when all strong references are removed, so if an image is referenced outside of the cache it will merely be disconnected from the cache by this method.

pub fn extend(&self, extension: Box<dyn ImagesExtension>)

Add an images service extension.

See ImagesExtension for extension capabilities.

pub fn available_formats(&self) -> Vec<ImageFormat>

Image formats implemented by the current view-process and extensions.

impl IMAGES

pub fn render<N, R>(&self, mask: Option<ImageMaskMode>, render: N) -> ImageVar

where N: FnOnce() -> R + Send + Sync + 'static, R: ImageRenderWindowRoot,

Render the window generated by render to an image.

The window is created as a headless surface and rendered to the returned image. You can set the IMAGE_RENDER.retain var inside render to create an image that updates with new frames. By default it will only render once.

The closure runs in the WINDOW context of the headless window.

This is shorthand for calling IMAGES.image with ImageSource::render and ImageOptions::none.

pub fn render_node( &self, render_mode: RenderMode, mask: Option<ImageMaskMode>, render: impl FnOnce() -> UiNode + Send + Sync + 'static, ) -> ImageVar

Render an UiNode to an image.

This method is a shortcut to render a node without needing to declare the headless window, note that a headless window is still used, the node does not have the same context as the calling widget.

This is shorthand for calling IMAGES.image with ImageSource::render_node and ImageOptions::none.