diff --git a/components/compositing/compositor.rs b/components/compositing/compositor.rs index 2673af8b439..b7eb2633e68 100644 --- a/components/compositing/compositor.rs +++ b/components/compositing/compositor.rs @@ -27,7 +27,7 @@ use script_traits::{TouchpadPressurePhase, TouchEventType, TouchId, WindowSizeDa use script_traits::CompositorEvent::{self, MouseMoveEvent, MouseButtonEvent, TouchEvent, TouchpadPressureEvent}; use servo_config::opts; use servo_config::prefs::PREFS; -use servo_geometry::ScreenPx; +use servo_geometry::DeviceIndependentPixel; use servo_url::ServoUrl; use std::collections::HashMap; use std::fs::File; @@ -155,10 +155,10 @@ pub struct IOCompositor { /// "Desktop-style" zoom that resizes the viewport to fit the window. /// See `ViewportPx` docs in util/geom.rs for details. - page_zoom: ScaleFactor, + page_zoom: ScaleFactor, /// The device pixel ratio for this window. - scale_factor: ScaleFactor, + scale_factor: ScaleFactor, channel_to_self: Box, @@ -378,7 +378,7 @@ impl IOCompositor { fn new(window: Rc, state: InitialCompositorState) -> IOCompositor { let window_size = window.framebuffer_size(); - let scale_factor = window.scale_factor(); + let scale_factor = window.hidpi_factor(); let composite_target = match opts::get().output_file { Some(_) => CompositeTarget::PngFile, None => CompositeTarget::Window @@ -756,7 +756,7 @@ impl IOCompositor { } fn send_window_size(&self, size_type: WindowSizeType) { - let dppx = self.page_zoom * self.device_pixels_per_screen_px(); + let dppx = self.page_zoom * self.hidpi_factor(); let initial_viewport = self.window_size.to_f32() / dppx; let visible_viewport = initial_viewport / self.viewport_zoom; let msg = ConstellationMsg::WindowSize(WindowSizeData { @@ -889,7 +889,7 @@ impl IOCompositor { debug!("compositor resizing to {:?}", new_size.to_untyped()); // A size change could also mean a resolution change. - let new_scale_factor = self.window.scale_factor(); + let new_scale_factor = self.window.hidpi_factor(); if self.scale_factor != new_scale_factor { self.scale_factor = new_scale_factor; self.update_zoom_transform(); @@ -948,7 +948,7 @@ impl IOCompositor { }; if let Some(pipeline) = self.pipeline(root_pipeline_id) { - let dppx = self.page_zoom * self.device_pixels_per_screen_px(); + let dppx = self.page_zoom * self.hidpi_factor(); let translated_point = (point / dppx).to_untyped(); let event_to_send = match mouse_window_event { MouseWindowEvent::Click(button, _) => { @@ -986,7 +986,7 @@ impl IOCompositor { return; } - let dppx = self.page_zoom * self.device_pixels_per_screen_px(); + let dppx = self.page_zoom * self.hidpi_factor(); let event_to_send = MouseMoveEvent(Some((cursor / dppx).to_untyped())); let msg = ConstellationControlMsg::SendEvent(root_pipeline_id, event_to_send); if let Some(pipeline) = self.pipeline(root_pipeline_id) { @@ -1012,7 +1012,7 @@ impl IOCompositor { fn on_touch_down(&mut self, identifier: TouchId, point: TypedPoint2D) { self.touch_handler.on_touch_down(identifier, point); - let dppx = self.page_zoom * self.device_pixels_per_screen_px(); + let dppx = self.page_zoom * self.hidpi_factor(); let translated_point = (point / dppx).to_untyped(); self.send_event_to_root_pipeline(TouchEvent(TouchEventType::Down, identifier, @@ -1042,7 +1042,7 @@ impl IOCompositor { }); } TouchAction::DispatchEvent => { - let dppx = self.page_zoom * self.device_pixels_per_screen_px(); + let dppx = self.page_zoom * self.hidpi_factor(); let translated_point = (point / dppx).to_untyped(); self.send_event_to_root_pipeline(TouchEvent(TouchEventType::Move, identifier, @@ -1053,7 +1053,7 @@ impl IOCompositor { } fn on_touch_up(&mut self, identifier: TouchId, point: TypedPoint2D) { - let dppx = self.page_zoom * self.device_pixels_per_screen_px(); + let dppx = self.page_zoom * self.hidpi_factor(); let translated_point = (point / dppx).to_untyped(); self.send_event_to_root_pipeline(TouchEvent(TouchEventType::Up, identifier, @@ -1066,7 +1066,7 @@ impl IOCompositor { fn on_touch_cancel(&mut self, identifier: TouchId, point: TypedPoint2D) { // Send the event to script. self.touch_handler.on_touch_cancel(identifier, point); - let dppx = self.page_zoom * self.device_pixels_per_screen_px(); + let dppx = self.page_zoom * self.hidpi_factor(); let translated_point = (point / dppx).to_untyped(); self.send_event_to_root_pipeline(TouchEvent(TouchEventType::Cancel, identifier, @@ -1078,7 +1078,7 @@ impl IOCompositor { pressure: f32, phase: TouchpadPressurePhase) { if let Some(true) = PREFS.get("dom.forcetouch.enabled").as_boolean() { - let dppx = self.page_zoom * self.device_pixels_per_screen_px(); + let dppx = self.page_zoom * self.hidpi_factor(); let translated_point = (point / dppx).to_untyped(); self.send_event_to_root_pipeline(TouchpadPressureEvent(translated_point, pressure, @@ -1291,7 +1291,7 @@ impl IOCompositor { } } - fn device_pixels_per_screen_px(&self) -> ScaleFactor { + fn hidpi_factor(&self) -> ScaleFactor { match opts::get().device_pixels_per_px { Some(device_pixels_per_px) => ScaleFactor::new(device_pixels_per_px), None => match opts::get().output_file { @@ -1302,7 +1302,7 @@ impl IOCompositor { } fn device_pixels_per_page_px(&self) -> ScaleFactor { - self.viewport_zoom * self.page_zoom * self.device_pixels_per_screen_px() + self.viewport_zoom * self.page_zoom * self.hidpi_factor() } fn update_zoom_transform(&mut self) { diff --git a/components/compositing/touch.rs b/components/compositing/touch.rs index a158c1e5c33..12bc365c77f 100644 --- a/components/compositing/touch.rs +++ b/components/compositing/touch.rs @@ -7,7 +7,7 @@ use euclid::scale_factor::ScaleFactor; use script_traits::{DevicePixel, EventResult, TouchId}; use self::TouchState::*; -/// Minimum number of `ScreenPx` to begin touch scrolling. +/// Minimum number of `DeviceIndependentPixel` to begin touch scrolling. const TOUCH_PAN_MIN_SCREEN_PX: f32 = 20.0; pub struct TouchHandler { @@ -100,7 +100,6 @@ impl TouchHandler { let action = match self.state { Touching => { let delta = point - old_point; - // TODO let delta: TypedPoint2D<_, ScreenPx> = delta / self.device_pixels_per_screen_px(); if delta.x.abs() > TOUCH_PAN_MIN_SCREEN_PX || delta.y.abs() > TOUCH_PAN_MIN_SCREEN_PX diff --git a/components/compositing/windowing.rs b/components/compositing/windowing.rs index 39b117c85b6..85d73af2f9f 100644 --- a/components/compositing/windowing.rs +++ b/components/compositing/windowing.rs @@ -12,7 +12,7 @@ use euclid::size::TypedSize2D; use msg::constellation_msg::{Key, KeyModifiers, KeyState}; use net_traits::net_error_list::NetError; use script_traits::{DevicePixel, MouseButton, TouchEventType, TouchId, TouchpadPressurePhase}; -use servo_geometry::ScreenPx; +use servo_geometry::DeviceIndependentPixel; use servo_url::ServoUrl; use std::fmt::{Debug, Error, Formatter}; use style_traits::cursor::Cursor; @@ -109,7 +109,7 @@ pub trait WindowMethods { /// Returns the size of the window in hardware pixels. fn framebuffer_size(&self) -> TypedSize2D; /// Returns the size of the window in density-independent "px" units. - fn size(&self) -> TypedSize2D; + fn size(&self) -> TypedSize2D; /// Presents the window to the screen (perhaps by page flipping). fn present(&self); @@ -137,8 +137,8 @@ pub trait WindowMethods { /// Called when the tag has finished parsing fn head_parsed(&self); - /// Returns the scale factor of the system (device pixels / screen pixels). - fn scale_factor(&self) -> ScaleFactor; + /// Returns the scale factor of the system (device pixels / device independent pixels). + fn hidpi_factor(&self) -> ScaleFactor; /// Creates a channel to the compositor. The dummy parameter is needed because we don't have /// UFCS in Rust yet. diff --git a/components/config/opts.rs b/components/config/opts.rs index df2bb2e041e..ca0c24f8d09 100644 --- a/components/config/opts.rs +++ b/components/config/opts.rs @@ -10,7 +10,7 @@ use getopts::Options; use num_cpus; use prefs::{self, PrefValue, PREFS}; use resource_files::set_resources_path; -use servo_geometry::ScreenPx; +use servo_geometry::DeviceIndependentPixel; use servo_url::ServoUrl; use std::borrow::Cow; use std::cmp; @@ -143,7 +143,7 @@ pub struct Opts { pub webdriver_port: Option, /// The initial requested size of the window. - pub initial_window_size: TypedSize2D, + pub initial_window_size: TypedSize2D, /// An optional string allowing the user agent to be set for testing. pub user_agent: Cow<'static, str>, diff --git a/components/geometry/lib.rs b/components/geometry/lib.rs index ddca8d71972..55c1a165295 100644 --- a/components/geometry/lib.rs +++ b/components/geometry/lib.rs @@ -20,17 +20,17 @@ use std::i32; /// should approximate a device-independent reference length. This unit corresponds to Android's /// "density-independent pixel" (dip), Mac OS X's "point", and Windows "device-independent pixel." /// -/// The relationship between DevicePixel and ScreenPx is defined by the OS. On most low-dpi -/// screens, one ScreenPx is equal to one DevicePixel. But on high-density screens it can be -/// some larger number. For example, by default on Apple "retina" displays, one ScreenPx equals -/// two DevicePixels. On Android "MDPI" displays, one ScreenPx equals 1.5 device pixels. +/// The relationship between DevicePixel and DeviceIndependentPixel is defined by the OS. On most low-dpi +/// screens, one DeviceIndependentPixel is equal to one DevicePixel. But on high-density screens it can be +/// some larger number. For example, by default on Apple "retina" displays, one DeviceIndependentPixel equals +/// two DevicePixels. On Android "MDPI" displays, one DeviceIndependentPixel equals 1.5 device pixels. /// -/// The ratio between ScreenPx and DevicePixel for a given display be found by calling +/// The ratio between DeviceIndependentPixel and DevicePixel for a given display be found by calling /// `servo::windowing::WindowMethods::hidpi_factor`. #[derive(Clone, Copy, Debug)] -pub enum ScreenPx {} +pub enum DeviceIndependentPixel {} -known_heap_size!(0, ScreenPx); +known_heap_size!(0, DeviceIndependentPixel); // An Au is an "App Unit" and represents 1/60th of a CSS pixel. It was // originally proposed in 2002 as a standard unit of measure in Gecko. diff --git a/components/servo/lib.rs b/components/servo/lib.rs index 38b9b7b8325..afda35f1582 100644 --- a/components/servo/lib.rs +++ b/components/servo/lib.rs @@ -149,7 +149,7 @@ impl Browser where Window: WindowMethods + 'static { let (webrender, webrender_api_sender) = { // TODO(gw): Duplicates device_pixels_per_screen_px from compositor. Tidy up! - let scale_factor = window.scale_factor().get(); + let scale_factor = window.hidpi_factor().get(); let device_pixel_ratio = match opts.device_pixels_per_px { Some(device_pixels_per_px) => device_pixels_per_px, None => match opts.output_file { diff --git a/components/style_traits/lib.rs b/components/style_traits/lib.rs index 4eadd640402..4ee378833a4 100644 --- a/components/style_traits/lib.rs +++ b/components/style_traits/lib.rs @@ -29,11 +29,11 @@ pub type UnsafeNode = (usize, usize); /// One CSS "px" in the coordinate system of the "initial viewport": /// http://www.w3.org/TR/css-device-adapt/#initial-viewport /// -/// `ViewportPx` is equal to `ScreenPx` times a "page zoom" factor controlled by the user. This is +/// `ViewportPx` is equal to `DeviceIndependentPixel` times a "page zoom" factor controlled by the user. This is /// the desktop-style "full page" zoom that enlarges content but then reflows the layout viewport /// so it still exactly fits the visible area. /// -/// At the default zoom level of 100%, one `PagePx` is equal to one `ScreenPx`. However, if the +/// At the default zoom level of 100%, one `PagePx` is equal to one `DeviceIndependentPixel`. However, if the /// document is zoomed in or out then this scale may be larger or smaller. #[derive(Clone, Copy, Debug)] pub enum ViewportPx {} @@ -50,7 +50,7 @@ pub enum PagePx {} // In summary, the hierarchy of pixel units and the factors to convert from one to the next: // // DevicePixel -// / hidpi_ratio => ScreenPx +// / hidpi_ratio => DeviceIndependentPixel // / desktop_zoom => ViewportPx // / pinch_zoom => PagePx diff --git a/ports/cef/window.rs b/ports/cef/window.rs index 958bc0b2221..4c31a890774 100644 --- a/ports/cef/window.rs +++ b/ports/cef/window.rs @@ -26,7 +26,7 @@ use gleam::gl; use msg::constellation_msg::{Key, KeyModifiers}; use net_traits::net_error_list::NetError; use script_traits::DevicePixel; -use servo_geometry::ScreenPx; +use servo_geometry::DeviceIndependentPixel; use std::cell::RefCell; use std::ffi::CString; use std::os::raw::{c_char, c_void}; @@ -206,7 +206,7 @@ impl WindowMethods for Window { } } - fn size(&self) -> TypedSize2D { + fn size(&self) -> TypedSize2D { let browser = self.cef_browser.borrow(); match *browser { None => TypedSize2D::new(400.0, 300.0), @@ -250,7 +250,7 @@ impl WindowMethods for Window { } } - fn scale_factor(&self) -> ScaleFactor { + fn hidpi_factor(&self) -> ScaleFactor { if cfg!(target_os="macos") { let browser = self.cef_browser.borrow(); match *browser { diff --git a/ports/glutin/window.rs b/ports/glutin/window.rs index 2ed98b0f682..338bb056ebd 100644 --- a/ports/glutin/window.rs +++ b/ports/glutin/window.rs @@ -28,7 +28,7 @@ use script_traits::{DevicePixel, TouchEventType, TouchpadPressurePhase}; use servo_config::opts; use servo_config::prefs::PREFS; use servo_config::resource_files; -use servo_geometry::ScreenPx; +use servo_geometry::DeviceIndependentPixel; use servo_url::ServoUrl; use std::cell::{Cell, RefCell}; #[cfg(any(target_os = "linux", target_os = "macos"))] @@ -193,12 +193,12 @@ pub struct Window { } #[cfg(not(target_os = "windows"))] -fn window_creation_scale_factor() -> ScaleFactor { +fn window_creation_scale_factor() -> ScaleFactor { ScaleFactor::new(1.0) } #[cfg(target_os = "windows")] -fn window_creation_scale_factor() -> ScaleFactor { +fn window_creation_scale_factor() -> ScaleFactor { let hdc = unsafe { user32::GetDC(::std::ptr::null_mut()) }; let ppi = unsafe { gdi32::GetDeviceCaps(hdc, winapi::wingdi::LOGPIXELSY) }; ScaleFactor::new(ppi as f32 / 96.0) @@ -207,7 +207,7 @@ fn window_creation_scale_factor() -> ScaleFactor { impl Window { pub fn new(is_foreground: bool, - window_size: TypedSize2D, + window_size: TypedSize2D, parent: Option) -> Rc { let win_size: TypedSize2D = (window_size.to_f32() * window_creation_scale_factor()) @@ -797,7 +797,7 @@ impl WindowMethods for Window { } } - fn size(&self) -> TypedSize2D { + fn size(&self) -> TypedSize2D { match self.kind { WindowKind::Window(ref window) => { // TODO(ajeffrey): can this fail? @@ -881,7 +881,7 @@ impl WindowMethods for Window { } #[cfg(not(target_os = "windows"))] - fn scale_factor(&self) -> ScaleFactor { + fn hidpi_factor(&self) -> ScaleFactor { match self.kind { WindowKind::Window(ref window) => { ScaleFactor::new(window.hidpi_factor()) @@ -893,7 +893,7 @@ impl WindowMethods for Window { } #[cfg(target_os = "windows")] - fn scale_factor(&self) -> ScaleFactor { + fn hidpi_factor(&self) -> ScaleFactor { let hdc = unsafe { user32::GetDC(::std::ptr::null_mut()) }; let ppi = unsafe { gdi32::GetDeviceCaps(hdc, winapi::wingdi::LOGPIXELSY) }; ScaleFactor::new(ppi as f32 / 96.0)