aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/api/android/mod.rs4
-rw-r--r--src/api/cocoa/mod.rs4
-rw-r--r--src/api/wayland/mod.rs4
-rw-r--r--src/api/win32/callback.rs46
-rw-r--r--src/api/win32/init.rs12
-rw-r--r--src/api/win32/mod.rs23
-rw-r--r--src/api/x11/window.rs4
-rw-r--r--src/lib.rs12
-rw-r--r--src/window.rs18
9 files changed, 112 insertions, 15 deletions
diff --git a/src/api/android/mod.rs b/src/api/android/mod.rs
index 3dcea90..f42caeb 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 c1b22c9..b7e0239 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 2877713..ab71ffa 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 45de907..5cd8ade 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<Option<ThreadLocalData>> = RefCe
pub struct ThreadLocalData {
pub win: winapi::HWND,
pub sender: Sender<Event>,
- pub cursor_state: Arc<Mutex<CursorState>>
+ pub window_state: Arc<Mutex<WindowState>>
+}
+
+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 67e4e4e..26ccba6 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<u16>, 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<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: window_state.clone()
};
(*context_stash.borrow_mut()) = Some(data);
});
@@ -237,7 +241,7 @@ unsafe fn init(title: Vec<u16>, 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 d85ef09..7a7f42a 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<Event>,
- /// The current cursor state.
- cursor_state: Arc<Mutex<CursorState>>,
+ /// The current window state.
+ window_state: Arc<Mutex<WindowState>>,
}
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 507b202..297a4f3 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 0246d52..c543155 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 86322bd..f2d6580 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]
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-29 15:07:45 +0000