Struct raw_window_handle::WindowHandle

pub struct WindowHandle<'a> {
    raw: RawWindowHandle,
    _marker: PhantomData<&'a ()>,
}

The handle to a window.

This is the primary return type of the HasWindowHandle trait. All pointers within this type are guaranteed to be valid and not dangling for the lifetime of the handle. This excludes window IDs like XIDs and the window ID for web platforms. See the documentation on the HasWindowHandle trait for more information about these safety requirements.

This handle is guaranteed to be safe and valid.

Fields

raw: RawWindowHandle

_marker: PhantomData<&'a ()>

Implementations

impl<'a> WindowHandle<'a>

pub unsafe fn borrow_raw(raw: RawWindowHandle) -> Self

Borrow a WindowHandle from a RawWindowHandle.

Safety

Users can safely assume that non-null/0 fields are valid handles, and it is up to the implementer of this trait to ensure that condition is upheld.

Despite that qualification, implementers should still make a best-effort attempt to fill in all available fields. If an implementation doesn’t, and a downstream user needs the field, it should try to derive the field from other fields the implementer does provide via whatever methods the platform provides.

Note that this guarantee only applies to pointers, and not any window ID types in the handle. This includes Window IDs (XIDs) from X11 and the window ID for web platforms. There is no way for Rust to enforce any kind of invariant on these types, since:

• For all three listed platforms, it is possible for safe code in the same process to delete the window.
• For X11, it is possible for code in a different process to delete the window. In fact, it is possible for code on a different machine to delete the window.

It is also possible for the window to be replaced with another, valid-but-different window. User code should be aware of this possibility, and should be ready to soundly handle the possible error conditions that can arise from this.

pub fn as_raw(&self) -> RawWindowHandle

Get the underlying raw window handle.

Trait Implementations

impl AsRef<RawWindowHandle> for WindowHandle<'_>

fn as_ref(&self) -> &RawWindowHandle

Converts this type into a shared reference of the (usually inferred) input type.

impl Borrow<RawWindowHandle> for WindowHandle<'_>

fn borrow(&self) -> &RawWindowHandle

Immutably borrows from an owned value.

impl<'a> Clone for WindowHandle<'a>

fn clone(&self) -> WindowHandle<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for WindowHandle<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<WindowHandle<'_>> for RawWindowHandle

fn from(handle: WindowHandle<'_>) -> Self

Converts to this type from the input type.

impl HasWindowHandle for WindowHandle<'_>

fn window_handle(&self) -> Result<Self, HandleError>

Get a handle to the window.

impl<'a> Hash for WindowHandle<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq for WindowHandle<'a>

fn eq(&self, other: &WindowHandle<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Copy for WindowHandle<'a>

impl<'a> Eq for WindowHandle<'a>

impl<'a> StructuralPartialEq for WindowHandle<'a>