win64 0.0.25

Hand-crafted, idiomatic Rust wrappers for Win32
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

#[cfg(any(feature = "rwh_06", feature = "rwh_05"))]
#[allow(unused)]
pub use inner::*;

#[cfg(all(feature = "rwh_05", not(any(feature = "rwh_06"))))]
pub mod inner {
  use {
    crate::{
      Handle,
      user::Window,
    },
    rwh_05::{
      ActiveHandle,
      DisplayHandle,
      HandleError,
      HasDisplayHandle,
      HasRawDisplayHandle,
      HasRawWindowHandle,
      HasWindowHandle,
      RawDisplayHandle,
      RawWindowHandle,
      Win32WindowHandle,
      WindowHandle,
      WindowsDisplayHandle,
    },
  };

  impl HasWindowHandle for Window {
    fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError> {
      Ok(unsafe { WindowHandle::borrow_raw(self.raw_window_handle(), ActiveHandle::new()) })
    }
  }

  unsafe impl HasRawWindowHandle for Window {
    fn raw_window_handle(&self) -> RawWindowHandle {
      let mut handle = Win32WindowHandle::empty();
      handle.hwnd = self.to_ptr().cast();
      handle.hinstance = self.instance().to_ptr();
      RawWindowHandle::Win32(handle)
    }
  }

  impl HasDisplayHandle for Window {
    fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
      Ok(unsafe { DisplayHandle::borrow_raw(self.raw_display_handle()) })
    }
  }

  unsafe impl HasRawDisplayHandle for Window {
    fn raw_display_handle(&self) -> RawDisplayHandle {
      RawDisplayHandle::Windows(WindowsDisplayHandle::empty())
    }
  }
}

#[cfg(all(feature = "rwh_06", not(any(feature = "rwh_05"))))]
mod inner {
  use {
    crate::{
      Handle,
      user::Window,
    },
    rwh_06::{
      DisplayHandle,
      HandleError,
      HasDisplayHandle,
      HasWindowHandle,
      RawDisplayHandle,
      RawWindowHandle,
      Win32WindowHandle,
      WindowHandle,
      WindowsDisplayHandle,
    },
    std::num::NonZero,
  };

  impl HasWindowHandle for Window {
    fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError> {
      let mut handle = Win32WindowHandle::new(NonZero::new(self.to_raw().cast_signed()).unwrap());
      handle.hinstance = Some(NonZero::new(self.instance().to_raw().cast_signed()).unwrap());
      Ok(unsafe { WindowHandle::borrow_raw(RawWindowHandle::from(handle)) })
    }
  }

  impl HasDisplayHandle for Window {
    fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
      let handle = WindowsDisplayHandle::new();
      Ok(unsafe { DisplayHandle::borrow_raw(RawDisplayHandle::Windows(handle)) })
    }
  }
}