Struct show_image::ContextHandle

pub struct ContextHandle<'a> { /* fields omitted */ }

Handle to the global context.

You can interact with the global context through a ContextHandle only from the global context thread. To interact with the context from a different thread, use a ContextProxy.

Implementations

impl<'a> ContextHandle<'a>

pub fn proxy(&self) -> ContextProxy

Get a proxy for the context to interact with it from a different thread.

You should not use proxy objects from withing the global context thread. The proxy objects often wait for the global context to perform some action. Doing so from within the global context thread would cause a deadlock.

pub fn set_exit_with_last_window(&mut self, exit_with_last_window: bool)

Exit the program when the last window closes.

pub fn create_window(
    &mut self,
    title: impl Into<String>,
    options: WindowOptions
) -> Result<WindowHandle<'_>, CreateWindowError>

Create a new window.

pub fn destroy_window(
    &mut self,
    window_id: WindowId
) -> Result<(), InvalidWindowId>

Destroy a window.

pub fn window_image_info(
    &self,
    window_id: WindowId
) -> Result<Option<(ImageInfo, Rectangle)>, InvalidWindowId>

Get the image info and the area where the image is drawn for a window.

pub fn set_window_visible(
    &mut self,
    window_id: WindowId,
    visible: bool
) -> Result<(), InvalidWindowId>

Make a window visible or invisible.

pub fn set_window_options<F>(
    &mut self,
    window_id: WindowId,
    make_options: F
) -> Result<(), InvalidWindowId> where
    F: FnOnce(&WindowOptions) -> WindowOptions, 

Change the options of a window.

pub fn set_window_image(
    &mut self,
    window_id: WindowId,
    name: impl Into<String>,
    image: &impl AsImageView
) -> Result<(), SetImageError>

Set the image to be displayed on a window.

pub fn add_window_overlay(
    &mut self,
    window_id: WindowId,
    name: impl Into<String>,
    image: &impl AsImageView
) -> Result<(), SetImageError>

Add an overlay to a window.

Overlays are drawn on top of the image. Overlays remain active until you call they are cleared.

pub fn clear_window_overlays(
    &mut self,
    window_id: WindowId
) -> Result<(), InvalidWindowId>

Clear the overlays of a window.

pub fn add_event_handler<F>(&mut self, handler: F) where
    F: 'static + FnMut(&mut ContextHandle<'_>, &mut Event, &mut EventHandlerControlFlow), 

Add a global event handler.

pub fn add_window_event_handler<F>(
    &mut self,
    window_id: WindowId,
    handler: F
) -> Result<(), InvalidWindowId> where
    F: 'static + FnMut(&mut WindowHandle<'_>, &mut WindowEvent, &mut EventHandlerControlFlow), 

Add a window-specific event handler.

pub fn run_background_task<F>(&mut self, task: F) where
    F: FnOnce() + Send + 'static, 

Run a task in a background thread and register it with the context.

The task will be executed in a different thread than the context. Currently, each task is spawned in a separate thread. In the future, tasks may be run in a dedicated thread pool.

The background task will be joined before the process is terminated when you use Self::exit() or one of the other exit functions of this crate.

pub fn exit(&mut self, code: i32) -> !

Join all background tasks and then exit the process.

If you use std::process::exit, running background tasks may be killed. To ensure no data loss occurs, you should use this function instead.

Background tasks are spawned when an image is saved through the built-in Ctrl+S or Ctrl+Shift+S shortcut, or by user code.