leyoda/winit
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rename "inner size" to "surface size" (#3889)

Browse source 
* Rename `WindowEvent::Resized` to `SurfaceResized`
* Rename `InnerSizeWriter` to `SurfaceSizeWriter`
* Replace `inner_size` with `surface_size`
* Rename `resize_increments` to `surface_resize_increments`
This commit is contained in:
Mads Marquart 2024-09-04 15:04:48 +02:00 • committed by GitHub
parent d37c591378
commit 8db3e0e043
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
32 changed files with 466 additions and 436 deletions
Download patch file Download diff file Expand all files Collapse all files

32
src/platform_impl/windows/event_loop.rs
View file

@ -58,7 +58,7 @@ use crate::application::ApplicationHandler;
use crate::dpi::{PhysicalPosition, PhysicalSize};
use crate::error::{EventLoopError, ExternalError, OsError};
use crate::event::{
Event, FingerId as RootFingerId, Force, Ime, InnerSizeWriter, RawKeyEvent, Touch, TouchPhase,
Event, FingerId as RootFingerId, Force, Ime, RawKeyEvent, SurfaceSizeWriter, Touch, TouchPhase,
WindowEvent,
};
use crate::event_loop::{
@ -1274,14 +1274,14 @@ unsafe fn public_window_callback_inner(
},
WM_SIZE => {
use crate::event::WindowEvent::Resized;
use crate::event::WindowEvent::SurfaceResized;
let w = super::loword(lparam as u32) as u32;
let h = super::hiword(lparam as u32) as u32;
let physical_size = PhysicalSize::new(w, h);
let event = Event::WindowEvent {
window_id: CoreWindowId(WindowId(window)),
event: Resized(physical_size),
event: SurfaceResized(physical_size),
};
{
@ -1308,7 +1308,7 @@ unsafe fn public_window_callback_inner(
let scale_factor = userdata.window_state_lock().scale_factor;
let Some(inc) = userdata
.window_state_lock()
.resize_increments
.surface_resize_increments
.map(|inc| inc.to_physical(scale_factor))
.filter(|inc| inc.width > 0 && inc.height > 0)
else {
@ -2131,7 +2131,7 @@ unsafe fn public_window_callback_inner(
// New size as suggested by Windows.
let suggested_rect = unsafe { *(lparam as *const RECT) };
// The window rect provided is the window's outer size, not it's inner size. However,
// The window rect provided is the window's outer size, not it's surface size. However,
// win32 doesn't provide an `UnadjustWindowRectEx` function to get the client rect from
// the outer rect, so we instead adjust the window rect to get the decoration margins
// and remove them from the outer size.
@ -2151,33 +2151,33 @@ unsafe fn public_window_callback_inner(
let old_physical_inner_rect = util::WindowArea::Inner
.get_rect(window)
.expect("failed to query (old) inner window area");
let old_physical_inner_size = PhysicalSize::new(
let old_physical_surface_size = PhysicalSize::new(
(old_physical_inner_rect.right - old_physical_inner_rect.left) as u32,
(old_physical_inner_rect.bottom - old_physical_inner_rect.top) as u32,
);
// `allow_resize` prevents us from re-applying DPI adjustment to the restored size after
// exiting fullscreen (the restored size is already DPI adjusted).
let new_physical_inner_size = match allow_resize {
let new_physical_surface_size = match allow_resize {
// We calculate our own size because the default suggested rect doesn't do a great
// job of preserving the window's logical size.
true => old_physical_inner_size
true => old_physical_surface_size
.to_logical::<f64>(old_scale_factor)
.to_physical::<u32>(new_scale_factor),
false => old_physical_inner_size,
false => old_physical_surface_size,
};
let new_inner_size = Arc::new(Mutex::new(new_physical_inner_size));
let new_surface_size = Arc::new(Mutex::new(new_physical_surface_size));
userdata.send_event(Event::WindowEvent {
window_id: CoreWindowId(WindowId(window)),
event: ScaleFactorChanged {
scale_factor: new_scale_factor,
inner_size_writer: InnerSizeWriter::new(Arc::downgrade(&new_inner_size)),
surface_size_writer: SurfaceSizeWriter::new(Arc::downgrade(&new_surface_size)),
},
});
let new_physical_inner_size = *new_inner_size.lock().unwrap();
drop(new_inner_size);
let new_physical_surface_size = *new_surface_size.lock().unwrap();
drop(new_surface_size);
let dragging_window: bool;
@ -2186,7 +2186,7 @@ unsafe fn public_window_callback_inner(
dragging_window =
window_state.window_flags().contains(WindowFlags::MARKER_IN_SIZE_MOVE);
// Unset maximized if we're changing the window's size.
if new_physical_inner_size != old_physical_inner_size {
if new_physical_surface_size != old_physical_surface_size {
WindowState::set_window_flags(window_state, window, |f| {
f.set(WindowFlags::MAXIMIZED, false)
});
@ -2201,8 +2201,8 @@ unsafe fn public_window_callback_inner(
let mut conservative_rect = RECT {
left: suggested_ul.0,
top: suggested_ul.1,
right: suggested_ul.0 + new_physical_inner_size.width as i32,
bottom: suggested_ul.1 + new_physical_inner_size.height as i32,
right: suggested_ul.0 + new_physical_surface_size.width as i32,
bottom: suggested_ul.1 + new_physical_surface_size.height as i32,
};
conservative_rect = window_flags

22
src/platform_impl/windows/event_loop/runner.rs
View file

@ -9,7 +9,7 @@ use windows_sys::Win32::Foundation::HWND;
use super::ControlFlow;
use crate::dpi::PhysicalSize;
use crate::event::{Event, InnerSizeWriter, StartCause, WindowEvent};
use crate::event::{Event, StartCause, SurfaceSizeWriter, WindowEvent};
use crate::platform_impl::platform::event_loop::{WindowData, GWL_USERDATA};
use crate::platform_impl::platform::get_window_long;
use crate::window::WindowId;
@ -357,12 +357,12 @@ impl BufferedEvent {
pub fn from_event(event: Event) -> BufferedEvent {
match event {
Event::WindowEvent {
event: WindowEvent::ScaleFactorChanged { scale_factor, inner_size_writer },
event: WindowEvent::ScaleFactorChanged { scale_factor, surface_size_writer },
window_id,
} => BufferedEvent::ScaleFactorChanged(
window_id,
scale_factor,
*inner_size_writer.new_inner_size.upgrade().unwrap().lock().unwrap(),
*surface_size_writer.new_surface_size.upgrade().unwrap().lock().unwrap(),
),
event => BufferedEvent::Event(event),
}
@ -371,29 +371,29 @@ impl BufferedEvent {
pub fn dispatch_event(self, dispatch: impl FnOnce(Event)) {
match self {
Self::Event(event) => dispatch(event),
Self::ScaleFactorChanged(window_id, scale_factor, new_inner_size) => {
let user_new_inner_size = Arc::new(Mutex::new(new_inner_size));
Self::ScaleFactorChanged(window_id, scale_factor, new_surface_size) => {
let user_new_surface_size = Arc::new(Mutex::new(new_surface_size));
dispatch(Event::WindowEvent {
window_id,
event: WindowEvent::ScaleFactorChanged {
scale_factor,
inner_size_writer: InnerSizeWriter::new(Arc::downgrade(
&user_new_inner_size,
surface_size_writer: SurfaceSizeWriter::new(Arc::downgrade(
&user_new_surface_size,
)),
},
});
let inner_size = *user_new_inner_size.lock().unwrap();
let surface_size = *user_new_surface_size.lock().unwrap();
drop(user_new_inner_size);
drop(user_new_surface_size);
if inner_size != new_inner_size {
if surface_size != new_surface_size {
let window_flags = unsafe {
let userdata =
get_window_long(window_id.0.into(), GWL_USERDATA) as *mut WindowData;
(*userdata).window_state_lock().window_flags
};
window_flags.set_size((window_id.0).0, inner_size);
window_flags.set_size((window_id.0).0, surface_size);
}
},
}

35
src/platform_impl/windows/window.rs
View file

@ -458,7 +458,7 @@ impl CoreWindow for Window {
}
}
fn inner_size(&self) -> PhysicalSize<u32> {
fn surface_size(&self) -> PhysicalSize<u32> {
let mut rect: RECT = unsafe { mem::zeroed() };
if unsafe { GetClientRect(self.hwnd(), &mut rect) } == false.into() {
panic!(
@ -478,14 +478,14 @@ impl CoreWindow for Window {
.unwrap()
}
fn request_inner_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
fn request_surface_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
let scale_factor = self.scale_factor();
let physical_size = size.to_physical::<u32>(scale_factor);
let window_flags = self.window_state_lock().window_flags;
window_flags.set_size(self.hwnd(), physical_size);
if physical_size != self.inner_size() {
if physical_size != self.surface_size() {
let window_state = Arc::clone(&self.window_state);
let window = self.window;
self.thread_executor.execute_in_thread(move || {
@ -499,28 +499,28 @@ impl CoreWindow for Window {
None
}
fn set_min_inner_size(&self, size: Option<Size>) {
fn set_min_surface_size(&self, size: Option<Size>) {
self.window_state_lock().min_size = size;
// Make windows re-check the window size bounds.
let size = self.inner_size();
let _ = self.request_inner_size(size.into());
let size = self.surface_size();
let _ = self.request_surface_size(size.into());
}
fn set_max_inner_size(&self, size: Option<Size>) {
fn set_max_surface_size(&self, size: Option<Size>) {
self.window_state_lock().max_size = size;
// Make windows re-check the window size bounds.
let size = self.inner_size();
let _ = self.request_inner_size(size.into());
let size = self.surface_size();
let _ = self.request_surface_size(size.into());
}
fn resize_increments(&self) -> Option<PhysicalSize<u32>> {
fn surface_resize_increments(&self) -> Option<PhysicalSize<u32>> {
let w = self.window_state_lock();
let scale_factor = w.scale_factor;
w.resize_increments.map(|size| size.to_physical(scale_factor))
w.surface_resize_increments.map(|size| size.to_physical(scale_factor))
}
fn set_resize_increments(&self, increments: Option<Size>) {
self.window_state_lock().resize_increments = increments;
fn set_surface_resize_increments(&self, increments: Option<Size>) {
self.window_state_lock().surface_resize_increments = increments;
}
fn set_resizable(&self, resizable: bool) {
@ -1209,13 +1209,14 @@ impl<'a> InitData<'a> {
win.set_enabled_buttons(attributes.enabled_buttons);
let size = attributes.inner_size.unwrap_or_else(|| PhysicalSize::new(800, 600).into());
let size = attributes.surface_size.unwrap_or_else(|| PhysicalSize::new(800, 600).into());
let max_size = attributes
.max_inner_size
.max_surface_size
.unwrap_or_else(|| PhysicalSize::new(f64::MAX, f64::MAX).into());
let min_size = attributes.min_inner_size.unwrap_or_else(|| PhysicalSize::new(0, 0).into());
let min_size =
attributes.min_surface_size.unwrap_or_else(|| PhysicalSize::new(0, 0).into());
let clamped_size = Size::clamp(size, min_size, max_size, win.scale_factor());
let _ = win.request_inner_size(clamped_size);
let _ = win.request_surface_size(clamped_size);
// let margins = MARGINS {
// cxLeftWidth: 1,

8
src/platform_impl/windows/window_state.rs
View file

@ -30,7 +30,7 @@ pub(crate) struct WindowState {
pub min_size: Option<Size>,
pub max_size: Option<Size>,
pub resize_increments: Option<Size>,
pub surface_resize_increments: Option<Size>,
pub window_icon: Option<Icon>,
pub taskbar_icon: Option<Icon>,
@ -151,10 +151,10 @@ impl WindowState {
last_position: None,
},
min_size: attributes.min_inner_size,
max_size: attributes.max_inner_size,
min_size: attributes.min_surface_size,
max_size: attributes.max_surface_size,
resize_increments: attributes.resize_increments,
surface_resize_increments: attributes.surface_resize_increments,
window_icon: attributes.window_icon.clone(),
taskbar_icon: None,