use std::ffi::{c_void, CString};
use std::ops::ControlFlow;
use crate::{CWindowConfig, CWindowEvent};
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct WindowConfig {
pub title: String,
pub default_width: u32,
pub default_height: u32,
pub default_x: u32,
pub default_y: u32,
pub visible: bool,
pub borderless_fullscreen: bool,
}
pub struct Window {
pub(crate) ptr: *mut (),
}
pub enum WindowEvent {
Other = 1,
CloseRequest,
ScaleFactorChange,
Resume,
RedrawRequest,
}
impl Drop for Window {
fn drop(&mut self) {
unsafe { crate::destroy_window(self.ptr) }
}
}
impl Window {
pub fn new(config: WindowConfig) -> Self {
let title = CString::new(config.title.as_bytes()).unwrap();
let config = CWindowConfig {
default_width: config.default_width,
default_height: config.default_height,
default_x: config.default_x,
default_y: config.default_y,
visible: config.visible,
borderless_fullscreen: config.borderless_fullscreen,
title: title.as_ptr(),
};
let window = unsafe { crate::create_window(config) };
Self { ptr: window }
}
pub fn set_visible(&mut self, visible: bool) {
unsafe { crate::set_visible(self.ptr, visible) }
}
pub fn set_title(&mut self, title: &str) {
let string = CString::new(title.to_string().as_bytes()).unwrap();
let bytes = string.as_ptr();
unsafe { crate::set_title(self.ptr, bytes) }
}
pub fn resize(&mut self, width: u32, height: u32) {
unsafe { crate::resize_window(self.ptr, width, height) }
}
pub fn set_fullscreen(&mut self, fullscreen: bool) {
unsafe { crate::set_fullscreen(self.ptr, fullscreen) }
}
fn translate_event(event: CWindowEvent) -> Option<WindowEvent> {
let event = match event {
CWindowEvent::AboutToWait => return None,
CWindowEvent::Other => WindowEvent::Other,
CWindowEvent::CloseRequest => WindowEvent::CloseRequest,
CWindowEvent::ScaleFactorChange => WindowEvent::ScaleFactorChange,
CWindowEvent::Resume => WindowEvent::Resume,
CWindowEvent::RedrawRequest => WindowEvent::RedrawRequest,
};
Some(event)
}
pub fn wait_for_event(&self) {
unsafe { crate::wait_for_event(self.ptr) }
}
pub fn pop_event(&self) -> bool {
unsafe { crate::pop_event(self.ptr) }
}
pub fn wait_for_resume(&mut self) {
unsafe { crate::wait_for_resume(self.ptr) }
}
pub fn run(&mut self, mut handler: impl FnMut(&mut Window, Option<WindowEvent>)) -> ! {
let window_ptr = self.ptr;
unsafe {
let closure = |c_event: CWindowEvent| {
handler(self, Self::translate_event(c_event));
};
let closure_data: Box<Box<dyn FnMut(CWindowEvent)>> = Box::new(Box::new(closure));
crate::set_event_handler(window_ptr, Box::into_raw(closure_data) as *mut _);
}
loop {
if !self.pop_event() {
unsafe { crate::run_event_handler(window_ptr, CWindowEvent::AboutToWait) };
}
}
}
pub fn request_redraw(&mut self) {
unsafe { crate::request_redraw(self.ptr) }
}
}
|
