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

Make size/position types generic over pixel type (#1277)

Browse source 
* Begin implementing DPI generics

* Fix multithreaded example

* Format

* Fix serde test

* hopefully fix most of the errors

* Fix dpi module errors

* More error fixings

* Format

* fix macos errors

* Another error pass

* Replace bad type signatures

* more fixins
This commit is contained in:
Osspial 2020-01-04 01:33:07 -05:00
parent b16042a047
commit 3a1e694c2f
40 changed files with 388 additions and 336 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/platform_impl/linux/x11/event_processor.rs
View file

@ -707,7 +707,7 @@ impl<T: 'static> EventProcessor<T> {
});
if cursor_moved == Some(true) {
let position =
PhysicalPosition::new(xev.event_x as f64, xev.event_y as f64);
PhysicalPosition::new(xev.event_x as i32, xev.event_y as i32);
callback(Event::WindowEvent {
window_id,
@ -814,7 +814,7 @@ impl<T: 'static> EventProcessor<T> {
});
let position =
PhysicalPosition::new(xev.event_x as f64, xev.event_y as f64);
PhysicalPosition::new(xev.event_x as i32, xev.event_y as i32);
// The mods field on this event isn't actually populated, so query the
// pointer device. In the future, we can likely remove this round-trip by
@ -883,7 +883,7 @@ impl<T: 'static> EventProcessor<T> {
.unwrap_or(2);
let position =
PhysicalPosition::new(xev.event_x as f64, xev.event_y as f64);
PhysicalPosition::new(xev.event_x as i32, xev.event_y as i32);
callback(Event::WindowEvent {
window_id,
@ -941,7 +941,7 @@ impl<T: 'static> EventProcessor<T> {
window_id,
event: WindowEvent::CursorMoved {
device_id: mkdid(util::VIRTUAL_CORE_POINTER),
position: location,
position: location.cast(),
modifiers,
},
});

6
src/platform_impl/linux/x11/monitor.rs
View file

@ -38,7 +38,7 @@ pub struct VideoMode {
impl VideoMode {
#[inline]
pub fn size(&self) -> PhysicalSize {
pub fn size(&self) -> PhysicalSize<u32> {
self.size.into()
}
@ -157,11 +157,11 @@ impl MonitorHandle {
self.id as u32
}
pub fn size(&self) -> PhysicalSize {
pub fn size(&self) -> PhysicalSize<u32> {
self.dimensions.into()
}
pub fn position(&self) -> PhysicalPosition {
pub fn position(&self) -> PhysicalPosition<i32> {
self.position.into()
}

8
src/platform_impl/linux/x11/util/geometry.rs
View file

@ -137,9 +137,9 @@ impl FrameExtentsHeuristic {
pub fn inner_pos_to_outer_logical(
&self,
mut logical: LogicalPosition,
mut logical: LogicalPosition<f64>,
factor: f64,
) -> LogicalPosition {
) -> LogicalPosition<f64> {
use self::FrameExtentsHeuristicPath::*;
if self.heuristic_path != UnsupportedBordered {
let frame_extents = self.frame_extents.as_logical(factor);
@ -166,9 +166,9 @@ impl FrameExtentsHeuristic {
pub fn inner_size_to_outer_logical(
&self,
mut logical: LogicalSize,
mut logical: LogicalSize<f64>,
factor: f64,
) -> LogicalSize {
) -> LogicalSize<f64> {
let frame_extents = self.frame_extents.as_logical(factor);
logical.width += frame_extents.left + frame_extents.right;
logical.height += frame_extents.top + frame_extents.bottom;

34
src/platform_impl/linux/x11/window.rs
View file

@ -138,17 +138,17 @@ impl UnownedWindow {
let max_inner_size: Option<(u32, u32)> = window_attrs
.max_inner_size
.map(|size| size.to_physical(dpi_factor).into());
.map(|size| size.to_physical::<u32>(dpi_factor).into());
let min_inner_size: Option<(u32, u32)> = window_attrs
.min_inner_size
.map(|size| size.to_physical(dpi_factor).into());
.map(|size| size.to_physical::<u32>(dpi_factor).into());
let dimensions = {
// x11 only applies constraints when the window is actively resized
// by the user, so we have to manually apply the initial constraints
let mut dimensions: (u32, u32) = window_attrs
.inner_size
.map(|size| size.to_physical(dpi_factor))
.map(|size| size.to_physical::<u32>(dpi_factor))
.or_else(|| Some((800, 600).into()))
.map(Into::into)
.unwrap();
@ -320,10 +320,10 @@ impl UnownedWindow {
{
let mut min_inner_size = window_attrs
.min_inner_size
.map(|size| size.to_physical(dpi_factor));
.map(|size| size.to_physical::<u32>(dpi_factor));
let mut max_inner_size = window_attrs
.max_inner_size
.map(|size| size.to_physical(dpi_factor));
.map(|size| size.to_physical::<u32>(dpi_factor));
if !window_attrs.resizable {
if util::wm_name_is_one_of(&["Xfwm4"]) {
warn!("To avoid a WM bug, disabling resizing has no effect on Xfwm4");
@ -941,7 +941,7 @@ impl UnownedWindow {
}
#[inline]
pub fn outer_position(&self) -> Result<PhysicalPosition, NotSupportedError> {
pub fn outer_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
let extents = (*self.shared_state.lock()).frame_extents.clone();
if let Some(extents) = extents {
let (x, y) = self.inner_position_physical();
@ -962,7 +962,7 @@ impl UnownedWindow {
}
#[inline]
pub fn inner_position(&self) -> Result<PhysicalPosition, NotSupportedError> {
pub fn inner_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
Ok(self.inner_position_physical().into())
}
@ -993,7 +993,7 @@ impl UnownedWindow {
#[inline]
pub fn set_outer_position(&self, position: Position) {
let (x, y) = position.to_physical(self.hidpi_factor()).into();
let (x, y) = position.to_physical::<i32>(self.hidpi_factor()).into();
self.set_position_physical(x, y);
}
@ -1007,12 +1007,12 @@ impl UnownedWindow {
}
#[inline]
pub fn inner_size(&self) -> PhysicalSize {
pub fn inner_size(&self) -> PhysicalSize<u32> {
self.inner_size_physical().into()
}
#[inline]
pub fn outer_size(&self) -> PhysicalSize {
pub fn outer_size(&self) -> PhysicalSize<u32> {
let extents = self.shared_state.lock().frame_extents.clone();
if let Some(extents) = extents {
let (width, height) = self.inner_size_physical();
@ -1039,7 +1039,7 @@ impl UnownedWindow {
#[inline]
pub fn set_inner_size(&self, size: Size) {
let dpi_factor = self.hidpi_factor();
let (width, height) = size.to_physical(dpi_factor).into();
let (width, height) = size.to_physical::<u32>(dpi_factor).into();
self.set_inner_size_physical(width, height);
}
@ -1063,7 +1063,7 @@ impl UnownedWindow {
pub fn set_min_inner_size(&self, dimensions: Option<Size>) {
self.shared_state.lock().min_inner_size = dimensions;
let physical_dimensions =
dimensions.map(|dimensions| dimensions.to_physical(self.hidpi_factor()).into());
dimensions.map(|dimensions| dimensions.to_physical::<u32>(self.hidpi_factor()).into());
self.set_min_inner_size_physical(physical_dimensions);
}
@ -1076,7 +1076,7 @@ impl UnownedWindow {
pub fn set_max_inner_size(&self, dimensions: Option<Size>) {
self.shared_state.lock().max_inner_size = dimensions;
let physical_dimensions =
dimensions.map(|dimensions| dimensions.to_physical(self.hidpi_factor()).into());
dimensions.map(|dimensions| dimensions.to_physical::<u32>(self.hidpi_factor()).into());
self.set_max_inner_size_physical(physical_dimensions);
}
@ -1135,10 +1135,10 @@ impl UnownedWindow {
let dpi_factor = self.hidpi_factor();
let min_inner_size = min_size
.map(|size| size.to_physical(dpi_factor))
.map(|size| size.to_physical::<u32>(dpi_factor))
.map(Into::into);
let max_inner_size = max_size
.map(|size| size.to_physical(dpi_factor))
.map(|size| size.to_physical::<u32>(dpi_factor))
.map(Into::into);
self.update_normal_hints(|normal_hints| {
normal_hints.set_min_size(min_inner_size);
@ -1274,7 +1274,7 @@ impl UnownedWindow {
#[inline]
pub fn set_cursor_position(&self, position: Position) -> Result<(), ExternalError> {
let (x, y) = position.to_physical(self.hidpi_factor()).into();
let (x, y) = position.to_physical::<i32>(self.hidpi_factor()).into();
self.set_cursor_position_physical(x, y)
}
@ -1287,7 +1287,7 @@ impl UnownedWindow {
#[inline]
pub fn set_ime_position(&self, spot: Position) {
let (x, y) = spot.to_physical(self.hidpi_factor()).into();
let (x, y) = spot.to_physical::<i32>(self.hidpi_factor()).into();
self.set_ime_position_physical(x, y);
}