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

Rename hidpi_factor to scale_factor (#1334)

Browse source 
* Rename hidpi_factor to scale_factor

* Deprecate WINIT_HIDPI_FACTOR environment variable in favor of WINIT_X11_SCALE_FACTOR

* Rename HiDpiFactorChanged to DpiChanged and update docs

I'm renaming it to DpiChanged instead of ScaleFactorChanged, since I'd
like Winit to expose the raw DPI value at some point in the near future,
and DpiChanged is a more apt name for that purpose.

* Format

* Fix macos and ios again

* Fix bad macos rebase
This commit is contained in:
Osspial 2020-01-03 14:52:27 -05:00
parent 85ea3f1d5d
commit d29f7f34aa
34 changed files with 252 additions and 248 deletions
Download patch file Download diff file Expand all files Collapse all files

20
src/platform_impl/macos/app_state.rs
View file

@ -181,19 +181,19 @@ impl Handler {
}
}
fn handle_hidpi_factor_changed_event(
fn handle_scale_factor_changed_event(
&self,
callback: &mut Box<dyn EventHandler + 'static>,
ns_window: IdRef,
suggested_size: LogicalSize<f64>,
hidpi_factor: f64,
scale_factor: f64,
) {
let mut size = suggested_size.to_physical(hidpi_factor);
let mut size = suggested_size.to_physical(scale_factor);
let new_inner_size = &mut size;
let event = Event::WindowEvent {
window_id: WindowId(get_window_id(*ns_window)),
event: WindowEvent::HiDpiFactorChanged {
hidpi_factor,
event: WindowEvent::DpiChanged {
scale_factor,
new_inner_size,
},
};
@ -201,22 +201,22 @@ impl Handler {
callback.handle_nonuser_event(event, &mut *self.control_flow.lock().unwrap());
let physical_size = *new_inner_size;
let logical_size = physical_size.to_logical(hidpi_factor);
let logical_size = physical_size.to_logical(scale_factor);
let size = NSSize::new(logical_size.width, logical_size.height);
unsafe { NSWindow::setContentSize_(*ns_window, size) };
}
fn handle_proxy(&self, proxy: EventProxy, callback: &mut Box<dyn EventHandler + 'static>) {
match proxy {
EventProxy::HiDpiFactorChangedProxy {
EventProxy::DpiChangedProxy {
ns_window,
suggested_size,
hidpi_factor,
} => self.handle_hidpi_factor_changed_event(
scale_factor,
} => self.handle_scale_factor_changed_event(
callback,
ns_window,
suggested_size,
hidpi_factor,
scale_factor,
),
}
}

4
src/platform_impl/macos/event.rs
View file

@ -22,10 +22,10 @@ pub enum EventWrapper {
#[derive(Debug, PartialEq)]
pub enum EventProxy {
HiDpiFactorChangedProxy {
DpiChangedProxy {
ns_window: IdRef,
suggested_size: LogicalSize<f64>,
hidpi_factor: f64,
scale_factor: f64,
},
}

10
src/platform_impl/macos/monitor.rs
View file

@ -168,7 +168,7 @@ impl fmt::Debug for MonitorHandle {
native_identifier: u32,
size: PhysicalSize<u32>,
position: PhysicalPosition<i32>,
hidpi_factor: f64,
scale_factor: f64,
}
let monitor_id_proxy = MonitorHandle {
@ -176,7 +176,7 @@ impl fmt::Debug for MonitorHandle {
native_identifier: self.native_identifier(),
size: self.size(),
position: self.position(),
hidpi_factor: self.hidpi_factor(),
scale_factor: self.scale_factor(),
};
monitor_id_proxy.fmt(f)
@ -204,7 +204,7 @@ impl MonitorHandle {
let display = CGDisplay::new(display_id);
let height = display.pixels_high();
let width = display.pixels_wide();
PhysicalSize::from_logical::<_, f64>((width as f64, height as f64), self.hidpi_factor())
PhysicalSize::from_logical::<_, f64>((width as f64, height as f64), self.scale_factor())
}
#[inline]
@ -212,11 +212,11 @@ impl MonitorHandle {
let bounds = unsafe { CGDisplayBounds(self.native_identifier()) };
PhysicalPosition::from_logical::<_, f64>(
(bounds.origin.x as f64, bounds.origin.y as f64),
self.hidpi_factor(),
self.scale_factor(),
)
}
pub fn hidpi_factor(&self) -> f64 {
pub fn scale_factor(&self) -> f64 {
let screen = match self.ns_screen() {
Some(screen) => screen,
None => return 1.0, // default to 1.0 when we can't find the screen

26
src/platform_impl/macos/window.rs
View file

@ -135,10 +135,10 @@ fn create_window(
Some(screen) => NSScreen::frame(screen),
None => {
let screen = NSScreen::mainScreen(nil);
let hidpi_factor = NSScreen::backingScaleFactor(screen) as f64;
let scale_factor = NSScreen::backingScaleFactor(screen) as f64;
let (width, height) = match attrs.inner_size {
Some(size) => {
let logical = size.to_logical(hidpi_factor);
let logical = size.to_logical(scale_factor);
(logical.width, logical.height)
}
None => (800.0, 600.0),
@ -446,7 +446,7 @@ impl UnownedWindow {
frame_rect.origin.x as f64,
util::bottom_left_to_top_left(frame_rect),
);
let dpi_factor = self.hidpi_factor();
let dpi_factor = self.scale_factor();
Ok(position.to_physical(dpi_factor))
}
@ -458,12 +458,12 @@ impl UnownedWindow {
content_rect.origin.x as f64,
util::bottom_left_to_top_left(content_rect),
);
let dpi_factor = self.hidpi_factor();
let dpi_factor = self.scale_factor();
Ok(position.to_physical(dpi_factor))
}
pub fn set_outer_position(&self, position: Position) {
let dpi_factor = self.hidpi_factor();
let dpi_factor = self.scale_factor();
let position = position.to_logical(dpi_factor);
let dummy = NSRect::new(
NSPoint::new(
@ -484,7 +484,7 @@ impl UnownedWindow {
let view_frame = unsafe { NSView::frame(*self.ns_view) };
let logical: LogicalSize<f64> =
(view_frame.size.width as f64, view_frame.size.height as f64).into();
let dpi_factor = self.hidpi_factor();
let dpi_factor = self.scale_factor();
logical.to_physical(dpi_factor)
}
@ -493,14 +493,14 @@ impl UnownedWindow {
let view_frame = unsafe { NSWindow::frame(*self.ns_window) };
let logical: LogicalSize<f64> =
(view_frame.size.width as f64, view_frame.size.height as f64).into();
let dpi_factor = self.hidpi_factor();
let dpi_factor = self.scale_factor();
logical.to_physical(dpi_factor)
}
#[inline]
pub fn set_inner_size(&self, size: Size) {
unsafe {
let dpi_factor = self.hidpi_factor();
let dpi_factor = self.scale_factor();
util::set_content_size_async(*self.ns_window, size.to_logical(dpi_factor));
}
}
@ -511,7 +511,7 @@ impl UnownedWindow {
width: 0.0,
height: 0.0,
}));
let dpi_factor = self.hidpi_factor();
let dpi_factor = self.scale_factor();
set_min_inner_size(*self.ns_window, dimensions.to_logical(dpi_factor));
}
}
@ -522,7 +522,7 @@ impl UnownedWindow {
width: std::f32::MAX as f64,
height: std::f32::MAX as f64,
}));
let dpi_factor = self.hidpi_factor();
let dpi_factor = self.scale_factor();
set_max_inner_size(*self.ns_window, dimensions.to_logical(dpi_factor));
}
}
@ -583,14 +583,14 @@ impl UnownedWindow {
}
#[inline]
pub fn hidpi_factor(&self) -> f64 {
pub fn scale_factor(&self) -> f64 {
unsafe { NSWindow::backingScaleFactor(*self.ns_window) as _ }
}
#[inline]
pub fn set_cursor_position(&self, cursor_position: Position) -> Result<(), ExternalError> {
let physical_window_position = self.inner_position().unwrap();
let dpi_factor = self.hidpi_factor();
let dpi_factor = self.scale_factor();
let window_position = physical_window_position.to_logical::<CGFloat>(dpi_factor);
let logical_cursor_position = cursor_position.to_logical::<CGFloat>(dpi_factor);
let point = appkit::CGPoint {
@ -929,7 +929,7 @@ impl UnownedWindow {
#[inline]
pub fn set_ime_position(&self, spot: Position) {
let dpi_factor = self.hidpi_factor();
let dpi_factor = self.scale_factor();
let logical_spot = spot.to_logical(dpi_factor);
unsafe {
view::set_ime_position(

28
src/platform_impl/macos/window_delegate.rs
View file

@ -48,18 +48,18 @@ pub struct WindowDelegateState {
impl WindowDelegateState {
pub fn new(window: &Arc<UnownedWindow>, initial_fullscreen: bool) -> Self {
let hidpi_factor = window.hidpi_factor();
let scale_factor = window.scale_factor();
let mut delegate_state = WindowDelegateState {
ns_window: window.ns_window.clone(),
ns_view: window.ns_view.clone(),
window: Arc::downgrade(&window),
initial_fullscreen,
previous_position: None,
previous_dpi_factor: hidpi_factor,
previous_dpi_factor: scale_factor,
};
if hidpi_factor != 1.0 {
delegate_state.emit_static_hidpi_factor_changed_event();
if scale_factor != 1.0 {
delegate_state.emit_static_scale_factor_changed_event();
}
delegate_state
@ -80,26 +80,26 @@ impl WindowDelegateState {
AppState::queue_event(EventWrapper::StaticEvent(event));
}
pub fn emit_static_hidpi_factor_changed_event(&mut self) {
let hidpi_factor = self.get_hidpi_factor();
if hidpi_factor == self.previous_dpi_factor {
pub fn emit_static_scale_factor_changed_event(&mut self) {
let scale_factor = self.get_scale_factor();
if scale_factor == self.previous_dpi_factor {
return ();
};
self.previous_dpi_factor = hidpi_factor;
let wrapper = EventWrapper::EventProxy(EventProxy::HiDpiFactorChangedProxy {
self.previous_dpi_factor = scale_factor;
let wrapper = EventWrapper::EventProxy(EventProxy::DpiChangedProxy {
ns_window: IdRef::retain(*self.ns_window),
suggested_size: self.view_size(),
hidpi_factor,
scale_factor,
});
AppState::queue_event(wrapper);
}
pub fn emit_resize_event(&mut self) {
let rect = unsafe { NSView::frame(*self.ns_view) };
let hidpi_factor = self.get_hidpi_factor();
let scale_factor = self.get_scale_factor();
let logical_size = LogicalSize::new(rect.size.width as f64, rect.size.height as f64);
let size = logical_size.to_physical(hidpi_factor);
let size = logical_size.to_physical(scale_factor);
self.emit_event(WindowEvent::Resized(size));
}
@ -114,7 +114,7 @@ impl WindowDelegateState {
}
}
fn get_hidpi_factor(&self) -> f64 {
fn get_scale_factor(&self) -> f64 {
(unsafe { NSWindow::backingScaleFactor(*self.ns_window) }) as f64
}
@ -301,7 +301,7 @@ extern "C" fn window_did_move(this: &Object, _: Sel, _: id) {
extern "C" fn window_did_change_backing_properties(this: &Object, _: Sel, _: id) {
trace!("Triggered `windowDidChangeBackingProperties:`");
with_state(this, |state| {
state.emit_static_hidpi_factor_changed_event();
state.emit_static_scale_factor_changed_event();
});
trace!("Completed `windowDidChangeBackingProperties:`");
}