baseview 0.2.2

Low-level windowing system geared towards making audio plugin UIs.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use crate::{platform, MouseCursor, WindowSize};
use dpi::Size;
use raw_window_handle::{
    DisplayHandle, HandleError, HasDisplayHandle, HasWindowHandle, WindowHandle,
};
use std::fmt::Debug;

/// A handle to the window given to a [`WindowHandler`](crate::WindowHandler), which it can then
/// use to perform various operations on the window itself.
#[derive(Clone)]
pub struct WindowContext {
    inner: platform::WindowContext,
}

impl WindowContext {
    pub(crate) fn new(inner: platform::WindowContext) -> Self {
        Self { inner }
    }

    /// Sets the [`MouseCursor`] icon to be displayed when the mouse cursor hovers this window.
    pub fn set_mouse_cursor(&self, mouse_cursor: MouseCursor) {
        self.inner.set_mouse_cursor(mouse_cursor);
    }

    /// Requests the window to be closed.
    ///
    /// This request is not immediate. When exactly it will be closed is platform-dependent.
    ///
    /// However, it is guaranteed to only get closed after all [`WindowHandler`](crate::WindowHandler)
    /// methods are completed, and soon enough to be perceived as instantaneous by the user.
    pub fn request_close(&self) {
        self.inner.request_close();
    }

    /// Returns `true` if this window currently has keyboard focus, `false` otherwise.
    pub fn has_focus(&self) -> bool {
        self.inner.has_focus()
    }

    /// Focuses this window.
    pub fn focus(&self) {
        self.inner.focus();
    }

    /// Resizes this window to the given `size`.
    ///
    /// The given `size` can either be in [physical](dpi::PhysicalSize) or
    /// [logical](dpi::LogicalSize) pixels.
    pub fn resize(&self, size: impl Into<Size>) {
        self.inner.resize(size.into());
    }

    /// Returns the current scale factor of this window.
    pub fn scale_factor(&self) -> f64 {
        self.inner.scale_factor()
    }

    /// Returns the current size of this window.
    pub fn size(&self) -> WindowSize {
        self.inner.size()
    }

    /// Returns a new lightweight [`PlatformHandle`] to this window.
    ///
    /// It can be sent across threads to access the underlying platform window and display connection.
    /// See the [`PlatformHandle`] documentation for more information.
    pub fn platform_handle(&self) -> PlatformHandle {
        PlatformHandle { inner: self.inner.platform_handle() }
    }

    /// Returns the [`GlContext`](crate::gl::GlContext) associated to this window.
    ///
    /// If the window was not created with a GL context, this will return [`None`].
    #[cfg(feature = "opengl")]
    pub fn gl_context(&self) -> Option<crate::gl::GlContext> {
        self.inner.gl_context()
    }
}

impl HasWindowHandle for WindowContext {
    fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError> {
        self.inner.window_handle().ok_or(HandleError::Unavailable)
    }
}

impl HasDisplayHandle for WindowContext {
    fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
        Ok(self.inner.display_handle())
    }
}

/// A lightweight handle to a window and its display connection.
///
/// This type implements both [`HasWindowHandle`] and [`HasDisplayHandle`], allowing users to access
/// the underlying platform window and display connection.
///
/// This type is cheaply [cloneable](Clone). All cloned handles will always refer to the same window and
/// display connection.
///
/// Unlike the [`WindowContext`] and [`WindowHandle`] types however, this handle can be safely sent,
/// used, and dropped across threads (it implements [`Send`] and [`Sync`]).
///
/// However, it is not guaranteed that this handle can be successfully used from other threads,
/// depending on the platform.
///
/// Similarly, this handle is actually a weak handle: while it remains safe to use, its methods
/// will always return [`HandleError::Unavailable`] if called after the window it refers to has been
/// destroyed.
///
/// # Platform compatibility notes
///
/// Depending on the platform, the [`PlatformHandle::window_handle`] method may return
/// [`HandleError::Unavailable`] if called from a thread other than the main thread. (Even if the
/// window is still alive and well)
#[derive(Clone)]
pub struct PlatformHandle {
    inner: platform::PlatformHandle,
}

// Assert that PlatformHandle implements both Send & Sync on all platforms
const _: () = {
    const fn assert_impl_all<T: Debug + Send + Sync>() {}
    let _: fn() = assert_impl_all::<PlatformHandle>;
};

impl HasWindowHandle for PlatformHandle {
    fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError> {
        self.inner.window_handle().ok_or(HandleError::Unavailable)
    }
}

impl HasDisplayHandle for PlatformHandle {
    fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
        Ok(self.inner.display_handle())
    }
}

impl Debug for PlatformHandle {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.inner.fmt(f)
    }
}