Struct show_image::WindowHandle

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

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,
    destroy_flag: Option<&'a mut bool>
) -> 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 set_outer_position(&self, position: impl Into<IVec2>)

Set the window position in pixels.

This will automatically un-maximize the window.

Some window managers or platforms may ignore this property.

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: impl Into<UVec2>)

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 set_fullscreen(&mut self, fullscreen: bool)

Set the window in fullscreen mode or back.

This will set the window to borderless fullscreen on the current monitor or back. Fullscreen is set if the argument is true, otherwise the window is returned to normal size.

Some window managers may ignore this property.

pub fn is_fullscreen(&self) -> bool

Check if the window is set to fullscreen mode.

Note that some window managers may ignore the request for fullscreen mode. In that case, this function may return true while the window is not displayed in fullscreen mode.

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

Set the image to display on the window.

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

Add an overlay to the window.

If the window already has an overlay with the same name, the overlay is overwritten.

Overlays are drawn on top of the image in the order that they are first added.

If you wish to change the order of existing overlays, you must remove and re-add the overlays.

pub fn remove_overlay(&mut self, name: &impl AsRef<str>) -> bool

Remove an overlay from the window.

Returns true if there was an overlay to remove.

pub fn clear_overlays(&mut self)

Remove all overlays from the window.

pub fn set_overlay_visible(
    &mut self,
    name: impl AsRef<str>,
    visible: bool
) -> Result<(), UnknownOverlay>

Disable a specific overlay.

The overlay is not removed, but it will not be rendered anymore untill you enable the overlay again.

pub fn toggle_overlay_visible(
    &mut self,
    name: impl AsRef<str>
) -> Result<(), UnknownOverlay>

Toggle an overlay between enabled and disabled.

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

Enable or disable all overlays for this 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.