alex/winit-sonoma-fix
1
0
Fork 0
mirror of https://github.com/italicsjenga/winit-sonoma-fix.git synced 2025-01-23 18:36:34 +11:00
Code Issues Projects Releases Packages Wiki Activity

Minimum/maximum dimensions for windows in win32 api

Browse source
This commit is contained in:
Aceeri 2015-11-09 01:42:54 -08:00
parent 5ca4e89dd4
commit 78eb4a5990
5 changed files with 98 additions and 13 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

59
src/api/win32/callback.rs
View file

@ -6,6 +6,7 @@ use std::sync::{Arc, Mutex};
use std::ffi::OsString;
use std::os::windows::ffi::OsStringExt;
use WindowAttributes;
use CursorState;
use Event;
use super::event;
@ -19,10 +20,26 @@ use winapi;
/// a thread-local variable.
thread_local!(pub static CONTEXT_STASH: RefCell<Option<ThreadLocalData>> = RefCell::new(None));
/// Contains information about states and the window for the callback.
#[derive(Clone)]
pub struct WindowState {
pub cursor_state: CursorState,
pub attributes: WindowAttributes
}
pub struct ThreadLocalData {
pub win: winapi::HWND,
pub sender: Sender<Event>,
pub cursor_state: Arc<Mutex<CursorState>>
pub window_state: Arc<Mutex<WindowState>>
//pub cursor_state: Arc<Mutex<CursorState>>
}
struct MinMaxInfo {
reserved: winapi::POINT, // Do not use/change
max_size: winapi::POINT,
max_position: winapi::POINT,
min_track: winapi::POINT,
max_track: winapi::POINT
}
/// Checks that the window is the good one, and if so send the event to it.
@ -240,9 +257,9 @@ pub unsafe extern "system" fn callback(window: winapi::HWND, msg: winapi::UINT,
let cstash = cstash.as_ref();
// there's a very bizarre borrow checker bug
// possibly related to rust-lang/rust/#23338
let _cursor_state = if let Some(cstash) = cstash {
if let Ok(cursor_state) = cstash.cursor_state.lock() {
match *cursor_state {
let _window_state = if let Some(cstash) = cstash {
if let Ok(window_state) = cstash.window_state.lock() {
match window_state.cursor_state {
CursorState::Normal => {
user32::SetCursor(user32::LoadCursorW(
ptr::null_mut(),
@ -281,6 +298,40 @@ pub unsafe extern "system" fn callback(window: winapi::HWND, msg: winapi::UINT,
0
},
winapi::WM_GETMINMAXINFO => {
let mut mmi = lparam as *mut MinMaxInfo;
//(*mmi).max_position = winapi::POINT { x: -8, y: -8 }; // The upper left corner of the window if it were maximized on the primary monitor.
//(*mmi).max_size = winapi::POINT { x: 200, y: 200 }; // The dimensions of the primary monitor.
CONTEXT_STASH.with(|context_stash| {
let cstash = context_stash.borrow();
let cstash = cstash.as_ref();
let _window_state = if let Some(cstash) = cstash {
if let Ok(window_state) = cstash.window_state.lock() {
match window_state.attributes.min_dimensions {
Some((width, height)) => {
(*mmi).min_track = winapi::POINT { x: width as i32, y: height as i32 };
},
None => {
(*mmi).min_track = winapi::POINT { x: 800, y: 600 };
}
}
match window_state.attributes.max_dimensions {
Some((width, height)) => {
(*mmi).max_track = winapi::POINT { x: width as i32, y: height as i32 };
},
None => { }
}
}
} else {
return
};
});
0
},
x if x == *super::WAKEUP_MSG_ID => {
use events::Event::Awakened;
send_event(window, Awakened);

8
src/api/win32/init.rs
View file

@ -5,6 +5,7 @@ use std::mem;
use std::thread;
use super::callback;
use super::callback::WindowState;
use super::Window;
use super::MonitorId;
use super::WindowWrapper;
@ -215,7 +216,7 @@ unsafe fn init(title: Vec<u16>, window: &WindowAttributes, pf_reqs: &PixelFormat
}
// Creating a mutex to track the current cursor state
let cursor_state = Arc::new(Mutex::new(CursorState::Normal));
let cursor_state = CursorState::Normal;
// filling the CONTEXT_STASH task-local storage so that we can start receiving events
let events_receiver = {
@ -225,7 +226,10 @@ unsafe fn init(title: Vec<u16>, window: &WindowAttributes, pf_reqs: &PixelFormat
let data = callback::ThreadLocalData {
win: real_window.0,
sender: tx.take().unwrap(),
cursor_state: cursor_state.clone()
window_state: Arc::new(Mutex::new(WindowState {
cursor_state: cursor_state.clone(),
attributes: window.clone()
}))
};
(*context_stash.borrow_mut()) = Some(data);
});

14
src/api/win32/mod.rs
View file

@ -54,7 +54,7 @@ pub struct Window {
events_receiver: Receiver<Event>,
/// The current cursor state.
cursor_state: Arc<Mutex<CursorState>>,
cursor_state: CursorState,
}
unsafe impl Send for Window {}
@ -258,14 +258,14 @@ impl Window {
}
pub fn set_cursor_state(&self, state: CursorState) -> Result<(), String> {
let mut current_state = self.cursor_state.lock().unwrap();
let mut current_state = self.cursor_state;
let foreground_thread_id = unsafe { user32::GetWindowThreadProcessId(self.window.0, ptr::null_mut()) };
let current_thread_id = unsafe { kernel32::GetCurrentThreadId() };
unsafe { user32::AttachThreadInput(foreground_thread_id, current_thread_id, 1) };
let res = match (state, *current_state) {
let res = match (state, current_state) {
(CursorState::Normal, CursorState::Normal) => Ok(()),
(CursorState::Hide, CursorState::Hide) => Ok(()),
(CursorState::Grab, CursorState::Grab) => Ok(()),
@ -273,7 +273,7 @@ impl Window {
(CursorState::Hide, CursorState::Normal) => {
unsafe {
user32::SetCursor(ptr::null_mut());
*current_state = CursorState::Hide;
current_state = CursorState::Hide;
Ok(())
}
},
@ -281,7 +281,7 @@ impl Window {
(CursorState::Normal, CursorState::Hide) => {
unsafe {
user32::SetCursor(user32::LoadCursorW(ptr::null_mut(), winapi::IDC_ARROW));
*current_state = CursorState::Normal;
current_state = CursorState::Normal;
Ok(())
}
},
@ -298,7 +298,7 @@ impl Window {
if user32::ClipCursor(&rect) == 0 {
return Err(format!("ClipCursor failed"));
}
*current_state = CursorState::Grab;
current_state = CursorState::Grab;
Ok(())
}
},
@ -309,7 +309,7 @@ impl Window {
if user32::ClipCursor(ptr::null()) == 0 {
return Err(format!("ClipCursor failed"));
}
*current_state = CursorState::Normal;
current_state = CursorState::Normal;
Ok(())
}
},

12
src/lib.rs
View file

@ -527,6 +527,16 @@ pub struct WindowAttributes {
/// The default is `None`.
pub dimensions: Option<(u32, u32)>,
/// The minimum dimensions a window can be, If this is `None`, the minimum will be set to 800x600.
///
/// The default is `None`.
pub min_dimensions: Option<(u32, u32)>,
/// The maximum dimensions a window can be, If this is `None`, the maximum will be the dimensions of the primary monitor.
///
/// The default is `None`.
pub max_dimensions: Option<(u32, u32)>,
/// If `Some`, the window will be in fullscreen mode with the given monitor.
///
/// The default is `None`.
@ -563,6 +573,8 @@ impl Default for WindowAttributes {
fn default() -> WindowAttributes {
WindowAttributes {
dimensions: None,
min_dimensions: None,
max_dimensions: None,
monitor: None,
title: "glutin window".to_owned(),
visible: true,

18
src/window.rs
View file

@ -52,6 +52,24 @@ impl<'a> WindowBuilder<'a> {
self.window.dimensions = Some((width, height));
self
}
/// Sets a minimum dimension size for the window
///
/// Width and height are in pixels.
#[inline]
pub fn with_min_dimensions(mut self, width: u32, height: u32) -> WindowBuilder<'a> {
self.window.min_dimensions = Some((width, height));
self
}
/// Sets a maximum dimension size for the window
///
/// Width and height are in pixels.
#[inline]
pub fn with_max_dimensions(mut self, width: u32, height: u32) -> WindowBuilder<'a> {
self.window.max_dimensions = Some((width, height));
self
}
/// Requests a specific title for the window.
#[inline]