Struct show_image::WindowHandle

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

Handle to a window.

A WindowHandle can be used to interact with a window from within the global context thread. To interact with a window from another thread, you need a WindowProxy.

Implementations

impl<'a> WindowHandle<'a>

pub fn new(context_handle: ContextHandle<'a>, index: usize) -> Self

Create a new window handle from a context handle and a window ID.

pub fn id(&self) -> WindowId

Get the window ID.

pub fn proxy(&self) -> WindowProxy

Get a proxy object for the window 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 release(self) -> ContextHandle<'a>

Release the window handle to get a ContextHandle.

This can be used inside a window event handler to gain access to the ContextHandle. If you do not need mutable access to the context, you can also use context_handle().

pub fn context_handle(&self) -> &ContextHandle<'a>

Get a reference to the context handle.

If you need mutable access to the context, use release() instead.

pub fn destroy(self) -> ContextHandle<'a>

Destroy the window.

Any subsequent operation on the window through an existing WindowProxy will return InvalidWindowId.

pub fn image_info(&self) -> Option<&ImageInfo>

Get the image info.

Returns None if no image is set for the window.

pub fn preserve_aspect_ratio(&self) -> bool

Check if the window will preserve the aspect ratio of images it displays.

pub fn set_preserve_aspect_ratio(&mut self, preserve_aspect_ratio: bool)

Set if the window will preserve the aspect ratio of images it displays.

pub fn background_color(&self) -> Color

Get the background color of the window.

pub fn set_background_color(&mut self, background_color: Color)

Set the background color of the window.

pub fn set_visible(&mut self, visible: bool)

Make the window visible or invisible.

pub fn inner_size(&self) -> UVec2

Get the inner size of the window in physical pixels.

This returns the size of the window contents, excluding borders, the title bar and other decorations.

pub fn outer_size(&self) -> UVec2

Get the outer size of the window in physical pixels.

This returns the size of the entire window, including borders, the title bar and other decorations.

pub fn set_inner_size(&mut self, size: [u32; 2])

Set the inner size of the window in pixels.

The size is excluding borders, the title bar and other decorations.

Some window managers may ignore this property.

pub fn set_resizable(&mut self, resizable: bool)

Set if the window should be resizable for the user.

Some window managers may ignore this property.

pub fn set_borderless(&mut self, borderless: bool)

Set if the window should be drawn without borders.

Some window managers may ignore this property.

pub fn overlays_visible(&self) -> bool

Check if the window is currently showing overlays.

pub fn set_overlays_visible(&mut self, overlays_visible: bool)

Enable or disable the overlays for this window.

pub fn set_image(&mut self, name: impl Into<String>, image: &ImageView<'_>)

Set the image to display on the window.

pub fn add_overlay(&mut self, name: impl Into<String>, image: &ImageView<'_>)

Add an overlay to the window.

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

pub fn clear_overlays(&mut self)

Clear the overlays of the window.

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

Add an event handler to the window.

pub fn transform(&self) -> Affine2

Get the image transformation.

The image transformation is applied to the image and all overlays in virtual window space.

Virtual window space goes from (0, 0) in the top left corner of the window to (1, 1) in the bottom right corner.

This transformation does not include scaling introduced by the Self::preserve_aspect_ratio() property. Use Self::effective_transform() if you need that.

pub fn effective_transform(&self) -> Affine2

Get the full effective transformation from image space to virtual window space.

This transformation maps the image coordinates to virtual window coordinates. Unlike Self::transform(), this function returns a transformation that include the scaling introduced by the Self::preserve_aspect_ratio() property. This is useful to transform between window coordinates and image coordinates.

If no image is set on the window yet, this returns the same transformation as Self::transform().

Virtual window space goes from (0, 0) in the top left corner of the window to (1, 1) in the bottom right corner.

Note that physical pixel locations must be transformed to virtual window coordinates first.

pub fn set_transform(&mut self, transform: Affine2)

Set the image transformation to a value.

The image transformation is applied to the image and all overlays in virtual window space.

Virtual window space goes from (0, 0) in the top left corner of the window to (1, 1) in the bottom right corner.

This transformation should not include any scaling related to the Self::preserve_aspect_ratio() property.

pub fn pre_apply_transform(&mut self, transform: Affine2)

Pre-apply a transformation to the existing image transformation.

This is equivalent to:

window.set_transform(transform * window.transform())

See Self::set_transform for more information about the image transformation.

pub fn post_apply_transform(&mut self, transform: Affine2)

Post-apply a transformation to the existing image transformation.

This is equivalent to:

window.set_transform(window.transform() * transform)

See Self::set_transform for more information about the image transformation.