ventana 0.0.2

A cross-platform, iterator-based windowing library
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

// Linux + Wayland
#[cfg(wayland_platform)]
pub use backend_wayland as wayland;
// Windows
#[cfg(windows_platform)]
pub use backend_win32 as win32;
// Linux + X11
#[cfg(x11_platform)]
pub use backend_x11 as x11;
#[cfg(wayland_platform)]
pub use wayland::Wayland;
#[cfg(windows_platform)]
pub use win32::Win32;
#[cfg(x11_platform)]
pub use x11::X11;
use {
  crate::monitor::Monitor,
  std::{
    collections::VecDeque,
    sync::Arc,
  },
  ventana_hal::{
    backend::Backend as BackendImpl,
    error::RequestError,
    settings::WindowSettings,
    window::BackendWindow,
  },
};

#[derive(Clone)]
pub struct Backend {
  backend: &'static dyn BackendImpl,
}

impl<T: BackendImpl + 'static> From<&'static T> for Backend {
  fn from(backend: &'static T) -> Self {
    Self { backend }
  }
}

impl Backend {
  /// Attempts to select a backend from the first-party backend implementations. Returns `RequestError::NotSupported` if none are available.
  pub fn auto() -> Result<Self, RequestError> {
    #[allow(unreachable_code)]
    {
      #[cfg(windows_platform)]
      return Ok(Win32::instance().into());
      #[cfg(x11_platform)]
      return Ok(X11::instance().into());
      #[cfg(wayland_platform)]
      return Ok(Wayland::instance().into());
      Err(RequestError::NotSupported("No supported backend available to auto-select from."))
    }
  }

  pub(crate) fn create_window(&self, settings: WindowSettings) -> Result<Arc<dyn BackendWindow>, RequestError> {
    self.backend.create_window(settings)
  }

  pub fn name(&self) -> &'static str {
    self.backend.name()
  }

  pub fn list_available_monitors(&self) -> VecDeque<Monitor> {
    self
      .backend
      .list_available_monitors()
      .into_iter()
      .map(Monitor::new)
      .collect()
  }

  pub fn primary_monitor(&self) -> Result<Monitor, RequestError> {
    self.backend.primary_monitor().map(Monitor::new)
  }
}