diff --git a/src/api/android/mod.rs b/src/api/android/mod.rs index 3dcea902..f42caeb1 100644 --- a/src/api/android/mod.rs +++ b/src/api/android/mod.rs @@ -120,6 +120,10 @@ impl Window { { use std::{mem, ptr}; + // not implemented + assert!(win_attribs.min_dimensions.is_none()); + assert!(win_attribs.max_dimensions.is_none()); + let opengl = opengl.clone().map_sharing(|w| &w.context); let native_window = unsafe { android_glue::get_native_window() }; diff --git a/src/api/cocoa/mod.rs b/src/api/cocoa/mod.rs index c1b22c9b..b7e0239e 100644 --- a/src/api/cocoa/mod.rs +++ b/src/api/cocoa/mod.rs @@ -268,6 +268,10 @@ impl Window { unimplemented!() } + // not implemented + assert!(win_attribs.min_dimensions.is_none()); + assert!(win_attribs.max_dimensions.is_none()); + match opengl.robustness { Robustness::RobustNoResetNotification | Robustness::RobustLoseContextOnReset => { return Err(CreationError::RobustnessNotSupported); diff --git a/src/api/wayland/mod.rs b/src/api/wayland/mod.rs index 2877713e..ab71ffae 100644 --- a/src/api/wayland/mod.rs +++ b/src/api/wayland/mod.rs @@ -257,6 +257,10 @@ impl Window { { use self::wayland::internals::FFI; + // not implemented + assert!(window.min_dimensions.is_none()); + assert!(window.max_dimensions.is_none()); + let wayland_context = match *WAYLAND_CONTEXT { Some(ref c) => c, None => return Err(CreationError::NotSupported), diff --git a/src/api/win32/callback.rs b/src/api/win32/callback.rs index 45de9075..5cd8ade5 100644 --- a/src/api/win32/callback.rs +++ b/src/api/win32/callback.rs @@ -6,9 +6,11 @@ use std::sync::{Arc, Mutex}; use std::ffi::OsString; use std::os::windows::ffi::OsStringExt; +use WindowAttributes; use CursorState; use Event; use super::event; +use super::WindowState; use user32; use shell32; @@ -22,7 +24,15 @@ thread_local!(pub static CONTEXT_STASH: RefCell> = RefCe pub struct ThreadLocalData { pub win: winapi::HWND, pub sender: Sender, - pub cursor_state: Arc> + pub window_state: Arc> +} + +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. @@ -241,8 +251,8 @@ pub unsafe extern "system" fn callback(window: winapi::HWND, msg: winapi::UINT, // 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 { + 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 +291,36 @@ 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: .., y: .. }; // The dimensions of the primary monitor. + + CONTEXT_STASH.with(|context_stash| { + match context_stash.borrow().as_ref() { + Some(cstash) => { + let window_state = cstash.window_state.lock().unwrap(); + + match window_state.attributes.min_dimensions { + Some((width, height)) => { + (*mmi).min_track = winapi::POINT { x: width as i32, y: height as i32 }; + }, + None => { } + } + + match window_state.attributes.max_dimensions { + Some((width, height)) => { + (*mmi).max_track = winapi::POINT { x: width as i32, y: height as i32 }; + }, + None => { } + } + }, + None => { } + } + }); + 0 + }, + x if x == *super::WAKEUP_MSG_ID => { use events::Event::Awakened; send_event(window, Awakened); diff --git a/src/api/win32/init.rs b/src/api/win32/init.rs index 67e4e4ea..26ccba65 100644 --- a/src/api/win32/init.rs +++ b/src/api/win32/init.rs @@ -5,6 +5,7 @@ use std::mem; use std::thread; use super::callback; +use super::WindowState; use super::Window; use super::MonitorId; use super::WindowWrapper; @@ -214,8 +215,11 @@ unsafe fn init(title: Vec, window: &WindowAttributes, pf_reqs: &PixelFormat user32::SetForegroundWindow(real_window.0); } - // Creating a mutex to track the current cursor state - let cursor_state = Arc::new(Mutex::new(CursorState::Normal)); + // Creating a mutex to track the current window state + let window_state = Arc::new(Mutex::new(WindowState { + cursor_state: CursorState::Normal, + attributes: window.clone() + })); // filling the CONTEXT_STASH task-local storage so that we can start receiving events let events_receiver = { @@ -225,7 +229,7 @@ unsafe fn init(title: Vec, window: &WindowAttributes, pf_reqs: &PixelFormat let data = callback::ThreadLocalData { win: real_window.0, sender: tx.take().unwrap(), - cursor_state: cursor_state.clone() + window_state: window_state.clone() }; (*context_stash.borrow_mut()) = Some(data); }); @@ -237,7 +241,7 @@ unsafe fn init(title: Vec, window: &WindowAttributes, pf_reqs: &PixelFormat window: real_window, context: context, events_receiver: events_receiver, - cursor_state: cursor_state, + window_state: window_state, }) } diff --git a/src/api/win32/mod.rs b/src/api/win32/mod.rs index d85ef099..7a7f42ae 100644 --- a/src/api/win32/mod.rs +++ b/src/api/win32/mod.rs @@ -42,6 +42,13 @@ lazy_static! { static ref WAKEUP_MSG_ID: u32 = unsafe { user32::RegisterWindowMessageA("Glutin::EventID".as_ptr() as *const i8) }; } +/// Contains information about states and the window for the callback. +#[derive(Clone)] +pub struct WindowState { + pub cursor_state: CursorState, + pub attributes: WindowAttributes +} + /// The Win32 implementation of the main `Window` object. pub struct Window { /// Main handle for the window. @@ -53,8 +60,8 @@ pub struct Window { /// Receiver for the events dispatched by the window callback. events_receiver: Receiver, - /// The current cursor state. - cursor_state: Arc>, + /// The current window state. + window_state: Arc>, } unsafe impl Send for Window {} @@ -258,14 +265,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.window_state.lock().unwrap().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 +280,7 @@ impl Window { (CursorState::Hide, CursorState::Normal) => { unsafe { user32::SetCursor(ptr::null_mut()); - *current_state = CursorState::Hide; + current_state = CursorState::Hide; Ok(()) } }, @@ -281,7 +288,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 +305,7 @@ impl Window { if user32::ClipCursor(&rect) == 0 { return Err(format!("ClipCursor failed")); } - *current_state = CursorState::Grab; + current_state = CursorState::Grab; Ok(()) } }, @@ -309,7 +316,7 @@ impl Window { if user32::ClipCursor(ptr::null()) == 0 { return Err(format!("ClipCursor failed")); } - *current_state = CursorState::Normal; + current_state = CursorState::Normal; Ok(()) } }, diff --git a/src/api/x11/window.rs b/src/api/x11/window.rs index 507b2026..297a4f32 100644 --- a/src/api/x11/window.rs +++ b/src/api/x11/window.rs @@ -305,6 +305,10 @@ impl Window { { let dimensions = window_attrs.dimensions.unwrap_or((800, 600)); + // not implemented + assert!(window_attrs.min_dimensions.is_none()); + assert!(window_attrs.max_dimensions.is_none()); + let screen_id = match window_attrs.monitor { Some(PlatformMonitorId::X(MonitorId(_, monitor))) => monitor as i32, _ => unsafe { (display.xlib.XDefaultScreen)(display.display) }, diff --git a/src/lib.rs b/src/lib.rs index 0246d520..c5431559 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -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 window will have no minimum dimensions (aside from reserved). + /// + /// The default is `None`. + pub min_dimensions: Option<(u32, u32)>, + + /// The maximum dimensions a window can be, If this is `None`, the maximum will have no maximum or will be set to the primary monitor's dimensions by the platform. + /// + /// 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, diff --git a/src/window.rs b/src/window.rs index 86322bd2..f2d65807 100644 --- a/src/window.rs +++ b/src/window.rs @@ -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]