use std::time::Duration;
use winapi::shared::guiddef::GUID;
use winapi::shared::minwindef::FILETIME;
use winapi::shared::windef::{HDC, HWND, POINT, RECT, SIZE};
use winapi::um::handleapi::*;
use winapi::um::synchapi::*;
use winapi::um::winbase::INFINITE;
use winapi::um::winnt::{HANDLE, LUID};
#[derive(Clone, Copy)]
pub struct Guid(pub GUID);
impl Guid {
pub const fn new(data1: u32, data2: u16, data3: u16, data4: [u8; 8]) -> Self {
Self(GUID {
Data1: data1,
Data2: data2,
Data3: data3,
Data4: data4,
})
}
}
impl From<GUID> for Guid {
fn from(src: GUID) -> Guid {
Guid(src)
}
}
impl From<Guid> for GUID {
fn from(src: Guid) -> GUID {
src.0
}
}
impl std::fmt::Debug for Guid {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(
f,
"{{{:x}-{:x}-{:x}-{:x}-",
self.0.Data1, self.0.Data2, self.0.Data3, self.0.Data4[0]
)?;
for i in 1..8 {
write!(f, "{:x}", self.0.Data4[i])?;
}
write!(f, "}}")
}
}
impl std::fmt::Display for Guid {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
std::fmt::Debug::fmt(self, f)
}
}
pub type Uuid = Guid;
#[derive(Clone, Debug)]
pub struct Luid(pub u64);
impl From<LUID> for Luid {
fn from(src: LUID) -> Luid {
Luid(src.LowPart as u64 | ((src.HighPart as u64) << 32))
}
}
impl From<Luid> for LUID {
fn from(src: Luid) -> LUID {
LUID {
LowPart: (src.0 & 0xffffffff) as u32,
HighPart: (src.0 >> 32) as i32,
}
}
}
#[derive(Clone, Copy, Default, Debug, PartialEq, Eq)]
#[repr(C)]
pub struct Point<T> {
pub x: T,
pub y: T,
}
impl<T> Point<T> {
pub fn new(x: T, y: T) -> Self {
Self { x, y }
}
}
impl<T> From<(T, T)> for Point<T> {
fn from(src: (T, T)) -> Point<T> {
Self::new(src.0, src.1)
}
}
impl From<POINT> for Point<i32> {
fn from(src: POINT) -> Point<i32> {
Point { x: src.x, y: src.y }
}
}
impl From<Point<i32>> for POINT {
fn from(src: Point<i32>) -> POINT {
POINT { x: src.x, y: src.y }
}
}
impl AsRef<POINT> for Point<i32> {
fn as_ref(&self) -> &POINT {
unsafe {
(self as *const Point<i32> as *const POINT)
.as_ref()
.unwrap()
}
}
}
#[derive(Clone, Copy, Default, Debug, PartialEq, Eq)]
#[repr(C)]
pub struct Size<T> {
pub width: T,
pub height: T,
}
impl<T> Size<T> {
pub fn new(width: T, height: T) -> Self {
Self { width, height }
}
}
impl<T> From<(T, T)> for Size<T> {
fn from(src: (T, T)) -> Size<T> {
Self::new(src.0, src.1)
}
}
impl From<SIZE> for Size<i32> {
fn from(src: SIZE) -> Size<i32> {
Size {
width: src.cx,
height: src.cy,
}
}
}
impl From<Size<i32>> for SIZE {
fn from(src: Size<i32>) -> SIZE {
SIZE {
cx: src.width,
cy: src.height,
}
}
}
impl AsRef<SIZE> for Size<i32> {
fn as_ref(&self) -> &SIZE {
unsafe { (self as *const Size<i32> as *const SIZE).as_ref().unwrap() }
}
}
#[derive(Clone, Copy, Default, Debug, PartialEq, Eq)]
#[repr(C)]
pub struct Rect<T> {
pub left: T,
pub top: T,
pub right: T,
pub bottom: T,
}
impl<T> Rect<T> {
pub fn new(left: T, top: T, right: T, bottom: T) -> Self {
Self {
left,
top,
right,
bottom,
}
}
}
impl<T: std::ops::Add<Output = T> + Copy> Rect<T> {
pub fn from_point_size(point: Point<T>, size: Size<T>) -> Self {
Self {
left: point.x,
top: point.y,
right: point.x + size.width,
bottom: point.y + size.height,
}
}
}
impl<T> From<(T, T, T, T)> for Rect<T> {
fn from(src: (T, T, T, T)) -> Rect<T> {
Self::new(src.0, src.1, src.2, src.3)
}
}
impl From<RECT> for Rect<i32> {
fn from(src: RECT) -> Rect<i32> {
Rect {
left: src.left,
top: src.top,
right: src.right,
bottom: src.bottom,
}
}
}
impl From<Rect<i32>> for RECT {
fn from(src: Rect<i32>) -> RECT {
RECT {
left: src.left,
top: src.top,
right: src.right,
bottom: src.bottom,
}
}
}
impl AsRef<RECT> for Rect<i32> {
fn as_ref(&self) -> &RECT {
unsafe { (self as *const Rect<i32> as *const RECT).as_ref().unwrap() }
}
}
pub struct Handle(HANDLE);
impl Handle {
pub fn new(p: HANDLE) -> Self {
Self(p)
}
pub fn as_raw_handle(&self) -> HANDLE {
self.0
}
}
impl Drop for Handle {
fn drop(&mut self) {
unsafe {
CloseHandle(self.0);
}
}
}
unsafe impl Send for Handle {}
unsafe impl Sync for Handle {}
pub struct EventHandle(std::sync::Arc<Handle>);
impl EventHandle {
pub fn new() -> Self {
unsafe {
let h = CreateEventW(std::ptr::null_mut(), 0, 0, std::ptr::null());
assert!(h != std::ptr::null_mut());
Self(std::sync::Arc::new(Handle::new(h)))
}
}
pub fn wait(&self, timeout: Option<Duration>) {
unsafe {
WaitForSingleObject(
self.0.as_raw_handle(),
timeout.map_or(INFINITE, |d| d.as_millis() as u32),
);
}
}
pub fn as_raw_handle(&self) -> HANDLE {
self.0.as_raw_handle()
}
}
unsafe impl Send for EventHandle {}
unsafe impl Sync for EventHandle {}
pub trait WindowHandle {
fn as_ptr(&self) -> *mut std::ffi::c_void;
fn as_hwnd(&self) -> HWND {
self.as_ptr() as _
}
}
impl WindowHandle for HWND {
fn as_ptr(&self) -> *mut std::ffi::c_void {
self.clone() as _
}
fn as_hwnd(&self) -> HWND {
self.clone()
}
}
impl WindowHandle for *mut std::ffi::c_void {
fn as_ptr(&self) -> *mut std::ffi::c_void {
self.clone()
}
}
impl WindowHandle for *const std::ffi::c_void {
fn as_ptr(&self) -> *mut std::ffi::c_void {
self.clone() as *mut std::ffi::c_void
}
}
pub trait DeviceContextHandle {
fn as_ptr(&self) -> *mut std::ffi::c_void;
fn as_hdc(&self) -> HDC {
self.as_ptr() as _
}
}
impl DeviceContextHandle for HDC {
fn as_ptr(&self) -> *mut std::ffi::c_void {
self.clone() as _
}
fn as_hdc(&self) -> HDC {
self.clone()
}
}
impl DeviceContextHandle for *mut std::ffi::c_void {
fn as_ptr(&self) -> *mut std::ffi::c_void {
self.clone()
}
}
#[derive(Clone, Copy, Debug)]
pub struct FileTime {
pub low_date_time: u32,
pub high_date_time: u32,
}
impl FileTime {
#[allow(dead_code)]
pub(crate) fn to_c_struct(&self) -> FILETIME {
FILETIME {
dwLowDateTime: self.low_date_time,
dwHighDateTime: self.high_date_time,
}
}
}
impl From<FILETIME> for FileTime {
fn from(src: FILETIME) -> FileTime {
FileTime {
low_date_time: src.dwLowDateTime,
high_date_time: src.dwHighDateTime,
}
}
}