ventana 0.0.1

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
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

pub mod iter;
pub mod raw;

use {
  crate::backend,
  std::sync::Arc,
  ventana_hal::{
    backend::Backend,
    dpi::{
      Position,
      Size,
    },
    error::RequestError,
    event::Event,
    settings::WindowSettings,
    types::{
      Flow,
      Visibility,
    },
    window::{
      BackendWindow,
      WindowId,
    },
  },
};

pub struct Window
where
  Self: Send + Sync,
{
  #[allow(unused)]
  backend: Arc<dyn Backend>,
  window: Arc<dyn BackendWindow>,
}

impl std::fmt::Debug for Window {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    f.debug_struct("Window")
      .field("backend", &self.backend.name())
      .field("window", &self.window.id())
      .finish()
  }
}

impl std::fmt::Display for Window {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    write!(f, "{backend}({id})", backend = self.backend.name(), id = self.window.id())
  }
}

impl Window {
  pub fn new(options: WindowOptions) -> Result<Self, RequestError> {
    let settings: WindowSettings = options.clone().into();
    let Some(backend) = options.backend else {
      return Err(RequestError::NotSupported("No backend selected"));
    };

    log::trace!("Creating window `{}`", settings.title);

    let window = backend.create_window(settings)?;
    Ok(Self { backend, window })
  }

  pub fn id(&self) -> WindowId {
    self.window.id()
  }

  pub fn title(&self) -> String {
    self.window.title()
  }

  pub fn inner_size(&self) -> Size {
    self.window.inner_size()
  }

  pub fn outer_size(&self) -> Size {
    self.window.outer_size()
  }

  pub fn inner_position(&self) -> Position {
    self.window.inner_position()
  }

  pub fn outer_position(&self) -> Position {
    self.window.outer_position()
  }

  pub fn next_event(&self) -> Option<Event> {
    self.window.next_event()
  }
}

#[derive(Clone)]
pub struct WindowOptions {
  pub backend: Option<Arc<dyn Backend>>,
  pub title: &'static str,
  pub size: Size, // Maybe should make this optional and have backend handle None case
  pub position: Option<Position>,
  pub visibility: Visibility,
  pub flow: Flow,
  pub close_on_x: bool,
}

impl Default for WindowOptions {
  fn default() -> Self {
    Self {
      backend: Self::auto_select_backend(),
      title: "Window",
      size: Size::Logical((800.0, 500.0).into()),
      position: None,
      visibility: Default::default(),
      flow: Default::default(),
      close_on_x: true,
    }
  }
}

impl WindowOptions {
  #[allow(unreachable_code)]
  fn auto_select_backend() -> Option<Arc<dyn Backend>> {
    #[cfg(windows_platform)]
    return Some(backend::Win32::instance());
    #[cfg(x11_platform)]
    return Some(backend::Wayland::instance());
    None
  }
}

impl From<WindowOptions> for WindowSettings {
  fn from(options: WindowOptions) -> Self {
    Self {
      title: options.title.into(),
      size: options.size,
      position: options.position,
      visibility: options.visibility,
      flow: options.flow,
      close_on_x: options.close_on_x,
    }
  }
}