witer 0.11.4

An iterator-based Win32 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
141
142
143

use std::num::NonZeroU32;

use glium::glutin::{
  api::wgl::{config::Config, display::Display},
  config::ConfigTemplateBuilder,
  context::PossiblyCurrentContext,
  display::GlDisplay,
  surface::{
    GlSurface,
    ResizeableSurface,
    Surface,
    SurfaceAttributes,
    SurfaceAttributesBuilder,
    SurfaceTypeTrait,
    WindowSurface,
  },
};
use raw_window_handle::{
  HasRawDisplayHandle,
  HasRawWindowHandle,
  RawDisplayHandle,
  RawWindowHandle,
};
use rwh_05 as raw_window_handle;

use crate::prelude::{Size, Window, WindowSettings};
// use winit::window::Window;

/// [`Window`] extensions for working with [`glutin`] surfaces.
pub trait GlWindow {
  fn build_surface_attributes(
    &self,
    builder: SurfaceAttributesBuilder<WindowSurface>,
  ) -> SurfaceAttributes<WindowSurface>;

  fn resize_surface(
    &self,
    surface: &Surface<impl SurfaceTypeTrait + ResizeableSurface>,
    context: &PossiblyCurrentContext,
  );
}

impl GlWindow for Window {
  fn build_surface_attributes(
    &self,
    builder: SurfaceAttributesBuilder<WindowSurface>,
  ) -> SurfaceAttributes<WindowSurface> {
    let (w, h) = self
      .inner_size()
      .non_zero()
      .expect("invalid zero inner size");
    builder.build(self.raw_window_handle(), w, h)
  }

  fn resize_surface(
    &self,
    surface: &Surface<impl SurfaceTypeTrait + ResizeableSurface>,
    context: &PossiblyCurrentContext,
  ) {
    if let Some((w, h)) = self.inner_size().non_zero() {
      surface.resize(context, w, h)
    }
  }
}

trait NonZeroU32PhysicalSize {
  fn non_zero(self) -> Option<(NonZeroU32, NonZeroU32)>;
}

impl NonZeroU32PhysicalSize for Size {
  fn non_zero(self) -> Option<(NonZeroU32, NonZeroU32)> {
    let w = NonZeroU32::new(self.width as u32)?;
    let h = NonZeroU32::new(self.height as u32)?;
    Some((w, h))
  }
}

use std::error::Error;

/// The helper to perform [`Display`] creation and OpenGL platform
/// bootstrapping with the help of [`winit`] with little to no platform specific
/// code.
///
/// This is only required for the initial setup. If you want to create
/// additional windows just use the [`finalize_window`] function and the
/// configuration you've used either for the original window or picked with the
/// existing [`Display`].
///
/// [`winit`]: winit
/// [`Display`]: glutin::display::Display
#[derive(Debug, Clone)]
pub struct DisplayBuilder {
  window_settings: WindowSettings,
}

impl DisplayBuilder {
  /// Create new display builder.
  pub fn new(window_settings: WindowSettings) -> Self {
    Self { window_settings }
  }

  /// The window builder to use when building a window.
  ///
  /// By default no window is created.
  pub fn with_window_settings(mut self, window_settings: WindowSettings) -> Self {
    self.window_settings = window_settings;
    self
  }

  pub fn build<Picker>(
    self,
    template_builder: ConfigTemplateBuilder,
    config_picker: Picker,
  ) -> Result<(Window, Config), Box<dyn Error>>
  where
    Picker: FnOnce(Box<dyn Iterator<Item = Config> + '_>) -> Config,
  {
    let window = Window::new(self.window_settings)?;

    let raw_window_handle = window.raw_window_handle();

    let gl_display =
      create_display(window.raw_display_handle(), Some(raw_window_handle))?;

    let template_builder =
      template_builder.compatible_with_native_window(raw_window_handle);
    let template = template_builder.build();

    let gl_config = unsafe {
      let configs = gl_display.find_configs(template)?;
      config_picker(configs)
    };

    Ok((window, gl_config))
  }
}

fn create_display(
  _raw_display_handle: RawDisplayHandle,
  _raw_window_handle: Option<RawWindowHandle>,
) -> Result<Display, Box<dyn Error>> {
  unsafe { Ok(Display::new(_raw_display_handle, _raw_window_handle)?) }
}