From e25dd451398905ed5e8eb3a29df5035fb1845492 Mon Sep 17 00:00:00 2001 From: Paul Rouget Date: Tue, 13 Mar 2018 14:36:00 +0800 Subject: [PATCH] alias some euclid types --- Cargo.lock | 1 + components/compositing/compositor.rs | 42 ++++++++++----------- components/compositing/compositor_thread.rs | 14 +++---- components/compositing/windowing.rs | 33 ++++++++-------- components/geometry/Cargo.toml | 1 + components/geometry/lib.rs | 6 ++- components/script/dom/screen.rs | 7 ++-- components/script/dom/window.rs | 4 +- components/script_traits/lib.rs | 4 +- components/script_traits/script_msg.rs | 15 ++++---- ports/servo/glutin_app/window.rs | 15 ++++---- 11 files changed, 73 insertions(+), 69 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 63096eaceb0..b800243f9b0 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2807,6 +2807,7 @@ dependencies = [ "euclid 0.17.2 (registry+https://github.com/rust-lang/crates.io-index)", "malloc_size_of 0.0.1", "malloc_size_of_derive 0.0.1", + "style_traits 0.0.1", "webrender_api 0.57.0 (git+https://github.com/servo/webrender)", ] diff --git a/components/compositing/compositor.rs b/components/compositing/compositor.rs index a05b2a5bccb..7b1d10f9702 100644 --- a/components/compositing/compositor.rs +++ b/components/compositing/compositor.rs @@ -6,7 +6,7 @@ use CompositionPipeline; use SendableFrameTree; use compositor_thread::{CompositorProxy, CompositorReceiver}; use compositor_thread::{InitialCompositorState, Msg}; -use euclid::{Length, TypedPoint2D, TypedVector2D, TypedScale}; +use euclid::{TypedPoint2D, TypedVector2D, TypedScale}; use gfx_traits::Epoch; use gleam::gl; use image::{DynamicImage, ImageFormat, RgbImage}; @@ -21,7 +21,7 @@ use script_traits::{MouseButton, MouseEventType, ScrollState, TouchEventType, To use script_traits::{UntrustedNodeAddress, WindowSizeData, WindowSizeType}; use script_traits::CompositorEvent::{MouseMoveEvent, MouseButtonEvent, TouchEvent}; use servo_config::opts; -use servo_geometry::DeviceIndependentPixel; +use servo_geometry::{DeviceIndependentPixel, DeviceUintLength}; use std::collections::HashMap; use std::fs::File; use std::rc::Rc; @@ -33,7 +33,7 @@ use style_traits::viewport::ViewportConstraints; use time::{precise_time_ns, precise_time_s}; use touch::{TouchHandler, TouchAction}; use webrender; -use webrender_api::{self, DeviceUintRect, DeviceUintSize, HitTestFlags, HitTestResult}; +use webrender_api::{self, DeviceIntPoint, DevicePoint, DeviceUintRect, DeviceUintSize, HitTestFlags, HitTestResult}; use webrender_api::{LayoutVector2D, ScrollEventPhase, ScrollLocation}; use windowing::{self, MouseWindowEvent, WebRenderDebugOption, WindowMethods}; @@ -201,7 +201,7 @@ struct ScrollZoomEvent { /// Scroll by this offset, or to Start or End scroll_location: ScrollLocation, /// Apply changes to the frame at this location - cursor: TypedPoint2D, + cursor: DeviceIntPoint, /// The scroll event phase. phase: ScrollEventPhase, /// The number of OS events that have been coalesced together into this one event. @@ -274,7 +274,7 @@ impl RenderTargetInfo { } } -fn initialize_png(gl: &gl::Gl, width: Length, height: Length) -> RenderTargetInfo { +fn initialize_png(gl: &gl::Gl, width: DeviceUintLength, height: DeviceUintLength) -> RenderTargetInfo { let framebuffer_ids = gl.gen_framebuffers(1); gl.bind_framebuffer(gl::FRAMEBUFFER, framebuffer_ids[0]); @@ -729,7 +729,7 @@ impl IOCompositor { } } - fn hit_test_at_point(&self, point: TypedPoint2D) -> HitTestResult { + fn hit_test_at_point(&self, point: DevicePoint) -> HitTestResult { let dppx = self.page_zoom * self.hidpi_factor(); let scaled_point = (point / dppx).to_untyped(); @@ -743,7 +743,7 @@ impl IOCompositor { } - pub fn on_mouse_window_move_event_class(&mut self, cursor: TypedPoint2D) { + pub fn on_mouse_window_move_event_class(&mut self, cursor: DevicePoint) { if opts::get().convert_mouse_to_touch { self.on_touch_move(TouchId(0), cursor); return @@ -752,7 +752,7 @@ impl IOCompositor { self.dispatch_mouse_window_move_event_class(cursor); } - fn dispatch_mouse_window_move_event_class(&mut self, cursor: TypedPoint2D) { + fn dispatch_mouse_window_move_event_class(&mut self, cursor: DevicePoint) { let root_pipeline_id = match self.get_root_pipeline_id() { Some(root_pipeline_id) => root_pipeline_id, None => return, @@ -784,7 +784,7 @@ impl IOCompositor { &self, event_type: TouchEventType, identifier: TouchId, - point: TypedPoint2D) + point: DevicePoint) { let results = self.hit_test_at_point(point); if let Some(item) = results.items.first() { @@ -805,7 +805,7 @@ impl IOCompositor { pub fn on_touch_event(&mut self, event_type: TouchEventType, identifier: TouchId, - location: TypedPoint2D) { + location: DevicePoint) { match event_type { TouchEventType::Down => self.on_touch_down(identifier, location), TouchEventType::Move => self.on_touch_move(identifier, location), @@ -814,12 +814,12 @@ impl IOCompositor { } } - fn on_touch_down(&mut self, identifier: TouchId, point: TypedPoint2D) { + fn on_touch_down(&mut self, identifier: TouchId, point: DevicePoint) { self.touch_handler.on_touch_down(identifier, point); self.send_touch_event(TouchEventType::Down, identifier, point); } - fn on_touch_move(&mut self, identifier: TouchId, point: TypedPoint2D) { + fn on_touch_move(&mut self, identifier: TouchId, point: DevicePoint) { match self.touch_handler.on_touch_move(identifier, point) { TouchAction::Scroll(delta) => { match point.cast() { @@ -850,7 +850,7 @@ impl IOCompositor { } } - fn on_touch_up(&mut self, identifier: TouchId, point: TypedPoint2D) { + fn on_touch_up(&mut self, identifier: TouchId, point: DevicePoint) { self.send_touch_event(TouchEventType::Up, identifier, point); if let TouchAction::Click = self.touch_handler.on_touch_up(identifier, point) { @@ -858,14 +858,14 @@ impl IOCompositor { } } - fn on_touch_cancel(&mut self, identifier: TouchId, point: TypedPoint2D) { + fn on_touch_cancel(&mut self, identifier: TouchId, point: DevicePoint) { // Send the event to script. self.touch_handler.on_touch_cancel(identifier, point); self.send_touch_event(TouchEventType::Cancel, identifier, point); } /// - fn simulate_mouse_click(&mut self, p: TypedPoint2D) { + fn simulate_mouse_click(&mut self, p: DevicePoint) { let button = MouseButton::Left; self.dispatch_mouse_window_move_event_class(p); self.dispatch_mouse_window_event_class(MouseWindowEvent::MouseDown(button, p)); @@ -875,7 +875,7 @@ impl IOCompositor { pub fn on_scroll_event(&mut self, delta: ScrollLocation, - cursor: TypedPoint2D, + cursor: DeviceIntPoint, phase: TouchEventType) { match phase { TouchEventType::Move => self.on_scroll_window_event(delta, cursor), @@ -890,7 +890,7 @@ impl IOCompositor { fn on_scroll_window_event(&mut self, scroll_location: ScrollLocation, - cursor: TypedPoint2D) { + cursor: DeviceIntPoint) { let event_phase = match (self.scroll_in_progress, self.in_scroll_transaction) { (false, None) => ScrollEventPhase::Start, (false, Some(last_scroll)) if last_scroll.elapsed() > Duration::from_millis(80) => @@ -909,7 +909,7 @@ impl IOCompositor { fn on_scroll_start_window_event(&mut self, scroll_location: ScrollLocation, - cursor: TypedPoint2D) { + cursor: DeviceIntPoint) { self.scroll_in_progress = true; self.pending_scroll_zoom_events.push(ScrollZoomEvent { magnification: 1.0, @@ -922,7 +922,7 @@ impl IOCompositor { fn on_scroll_end_window_event(&mut self, scroll_location: ScrollLocation, - cursor: TypedPoint2D) { + cursor: DeviceIntPoint) { self.scroll_in_progress = false; self.pending_scroll_zoom_events.push(ScrollZoomEvent { magnification: 1.0, @@ -1375,8 +1375,8 @@ impl IOCompositor { fn draw_img(&self, render_target_info: RenderTargetInfo, - width: Length, - height: Length) + width: DeviceUintLength, + height: DeviceUintLength) -> RgbImage { let width = width.get() as usize; let height = height.get() as usize; diff --git a/components/compositing/compositor_thread.rs b/components/compositing/compositor_thread.rs index 143107504e2..d93c2c4a2bd 100644 --- a/components/compositing/compositor_thread.rs +++ b/components/compositing/compositor_thread.rs @@ -6,7 +6,6 @@ use SendableFrameTree; use compositor::CompositingReason; -use euclid::{TypedPoint2D, TypedSize2D}; use gfx_traits::Epoch; use ipc_channel::ipc::IpcSender; use msg::constellation_msg::{Key, KeyModifiers, KeyState, PipelineId, TopLevelBrowsingContextId}; @@ -17,11 +16,10 @@ use script_traits::{AnimationState, ConstellationMsg, EventResult, LoadData}; use servo_url::ServoUrl; use std::fmt::{Debug, Error, Formatter}; use std::sync::mpsc::{Receiver, Sender}; -use style_traits::DevicePixel; use style_traits::cursor::CursorKind; use style_traits::viewport::ViewportConstraints; use webrender; -use webrender_api; +use webrender_api::{self, DeviceIntPoint, DeviceUintSize}; /// Used to wake up the event loop, provided by the servo port/embedder. @@ -120,16 +118,16 @@ pub enum EmbedderMsg { /// Alerts the embedder that the current page has changed its title. ChangePageTitle(TopLevelBrowsingContextId, Option), /// Move the window to a point - MoveTo(TopLevelBrowsingContextId, TypedPoint2D), + MoveTo(TopLevelBrowsingContextId, DeviceIntPoint), /// Resize the window to size - ResizeTo(TopLevelBrowsingContextId, TypedSize2D), + ResizeTo(TopLevelBrowsingContextId, DeviceUintSize), /// Get Window Informations size and position GetClientWindow(TopLevelBrowsingContextId, - IpcSender<(TypedSize2D, TypedPoint2D)>), + IpcSender<(DeviceUintSize, DeviceIntPoint)>), /// Get screen size (pixel) - GetScreenSize(TopLevelBrowsingContextId, IpcSender<(TypedSize2D)>), + GetScreenSize(TopLevelBrowsingContextId, IpcSender<(DeviceUintSize)>), /// Get screen available size (pixel) - GetScreenAvailSize(TopLevelBrowsingContextId, IpcSender<(TypedSize2D)>), + GetScreenAvailSize(TopLevelBrowsingContextId, IpcSender<(DeviceUintSize)>), /// Wether or not to follow a link AllowNavigation(TopLevelBrowsingContextId, ServoUrl, IpcSender), /// Sends an unconsumed key event back to the embedder. diff --git a/components/compositing/windowing.rs b/components/compositing/windowing.rs index 4be339718fe..5ada92b3249 100644 --- a/components/compositing/windowing.rs +++ b/components/compositing/windowing.rs @@ -5,25 +5,25 @@ //! Abstract windowing methods. The concrete implementations of these can be found in `platform/`. use compositor_thread::EventLoopWaker; -use euclid::{Length, TypedScale, TypedPoint2D, TypedSize2D}; +use euclid::TypedScale; use gleam::gl; use ipc_channel::ipc::IpcSender; use msg::constellation_msg::{Key, KeyModifiers, KeyState, TopLevelBrowsingContextId, TraversalDirection}; use net_traits::net_error_list::NetError; use script_traits::{LoadData, MouseButton, TouchEventType, TouchId}; -use servo_geometry::DeviceIndependentPixel; +use servo_geometry::{DeviceIndependentPixel, DeviceUintLength}; use servo_url::ServoUrl; use std::fmt::{Debug, Error, Formatter}; use std::rc::Rc; use style_traits::DevicePixel; use style_traits::cursor::CursorKind; -use webrender_api::{DeviceUintSize, DeviceUintRect, ScrollLocation}; +use webrender_api::{DeviceIntPoint, DeviceSize, DevicePoint, DeviceUintSize, DeviceUintRect, ScrollLocation}; #[derive(Clone)] pub enum MouseWindowEvent { - Click(MouseButton, TypedPoint2D), - MouseDown(MouseButton, TypedPoint2D), - MouseUp(MouseButton, TypedPoint2D), + Click(MouseButton, DevicePoint), + MouseDown(MouseButton, DevicePoint), + MouseUp(MouseButton, DevicePoint), } /// Various debug and profiling flags that WebRender supports. @@ -54,12 +54,12 @@ pub enum WindowEvent { /// Sent when a mouse hit test is to be performed. MouseWindowEventClass(MouseWindowEvent), /// Sent when a mouse move. - MouseWindowMoveEventClass(TypedPoint2D), + MouseWindowMoveEventClass(DevicePoint), /// Touch event: type, identifier, point - Touch(TouchEventType, TouchId, TypedPoint2D), + Touch(TouchEventType, TouchId, DevicePoint), /// Sent when the user scrolls. The first point is the delta and the second point is the /// origin. - Scroll(ScrollLocation, TypedPoint2D, TouchEventType), + Scroll(ScrollLocation, DeviceIntPoint, TouchEventType), /// Sent when the user zooms. Zoom(f32), /// Simulated "pinch zoom" gesture for non-touch platforms (e.g. ctrl-scrollwheel). @@ -123,21 +123,20 @@ pub trait WindowMethods { /// Returns the position and size of the window within the rendering area. fn window_rect(&self) -> DeviceUintRect; /// Returns the size of the window. - fn size(&self) -> TypedSize2D; + fn size(&self) -> DeviceSize; /// Presents the window to the screen (perhaps by page flipping). fn present(&self); /// Return the size of the window with head and borders and position of the window values - fn client_window(&self, ctx: TopLevelBrowsingContextId) -> - (TypedSize2D, TypedPoint2D); + fn client_window(&self, ctx: TopLevelBrowsingContextId) -> (DeviceUintSize, DeviceIntPoint); /// Return the size of the screen. - fn screen_size(&self, ctx: TopLevelBrowsingContextId) -> TypedSize2D; + fn screen_size(&self, ctx: TopLevelBrowsingContextId) -> DeviceUintSize; /// Return the available size of the screen. - fn screen_avail_size(&self, ctx: TopLevelBrowsingContextId) -> TypedSize2D; + fn screen_avail_size(&self, ctx: TopLevelBrowsingContextId) -> DeviceUintSize; /// Set the size inside of borders and head - fn set_inner_size(&self, ctx: TopLevelBrowsingContextId, size: TypedSize2D); + fn set_inner_size(&self, ctx: TopLevelBrowsingContextId, size: DeviceUintSize); /// Set the window position - fn set_position(&self, ctx: TopLevelBrowsingContextId, point: TypedPoint2D); + fn set_position(&self, ctx: TopLevelBrowsingContextId, point: DeviceIntPoint); /// Set fullscreen state fn set_fullscreen_state(&self, ctx: TopLevelBrowsingContextId, state: bool); @@ -167,7 +166,7 @@ pub trait WindowMethods { /// Requests that the window system prepare a composite. Typically this will involve making /// some type of platform-specific graphics context current. Returns true if the composite may /// proceed and false if it should not. - fn prepare_for_composite(&self, width: Length, height: Length) -> bool; + fn prepare_for_composite(&self, width: DeviceUintLength, height: DeviceUintLength) -> bool; /// Sets the cursor to be used in the window. fn set_cursor(&self, cursor: CursorKind); diff --git a/components/geometry/Cargo.toml b/components/geometry/Cargo.toml index 8ca688bd64c..d37b8b9e64d 100644 --- a/components/geometry/Cargo.toml +++ b/components/geometry/Cargo.toml @@ -14,4 +14,5 @@ app_units = "0.6" euclid = "0.17" malloc_size_of = { path = "../malloc_size_of" } malloc_size_of_derive = { path = "../malloc_size_of_derive" } +style_traits = { path = "../style_traits" } webrender_api = { git = "https://github.com/servo/webrender" } diff --git a/components/geometry/lib.rs b/components/geometry/lib.rs index c22c9d16055..c4bb9721bf6 100644 --- a/components/geometry/lib.rs +++ b/components/geometry/lib.rs @@ -5,16 +5,20 @@ extern crate app_units; extern crate euclid; extern crate malloc_size_of; +extern crate style_traits; #[macro_use] extern crate malloc_size_of_derive; extern crate webrender_api; use app_units::{Au, MAX_AU, MIN_AU}; -use euclid::{Point2D, Rect, Size2D}; +use euclid::{Length, Point2D, Rect, Size2D}; use std::f32; +use style_traits::DevicePixel; use webrender_api::{LayoutPoint, LayoutRect, LayoutSize}; // Units for use with euclid::length and euclid::scale_factor. +pub type DeviceUintLength = Length; + /// A normalized "pixel" at the default resolution for the display. /// /// Like the CSS "px" unit, the exact physical size of this unit may vary between devices, but it diff --git a/components/script/dom/screen.rs b/components/script/dom/screen.rs index 6893bf6c8da..e83cffd93a4 100644 --- a/components/script/dom/screen.rs +++ b/components/script/dom/screen.rs @@ -14,7 +14,8 @@ use dom_struct::dom_struct; use euclid::TypedSize2D; use ipc_channel::ipc; use script_traits::ScriptMsg; -use style_traits::{CSSPixel, DevicePixel}; +use style_traits::CSSPixel; +use webrender_api::DeviceUintSize; #[dom_struct] pub struct Screen { @@ -37,7 +38,7 @@ impl Screen { } fn screen_size(&self) -> TypedSize2D { - let (send, recv) = ipc::channel::<(TypedSize2D)>().unwrap(); + let (send, recv) = ipc::channel::().unwrap(); self.window.upcast::() .script_to_constellation_chan().send(ScriptMsg::GetScreenSize(send)).unwrap(); let dpr = self.window.device_pixel_ratio(); @@ -46,7 +47,7 @@ impl Screen { } fn screen_avail_size(&self) -> TypedSize2D { - let (send, recv) = ipc::channel::<(TypedSize2D)>().unwrap(); + let (send, recv) = ipc::channel::().unwrap(); self.window.upcast::() .script_to_constellation_chan().send(ScriptMsg::GetScreenAvailSize(send)).unwrap(); let dpr = self.window.device_pixel_ratio(); diff --git a/components/script/dom/window.rs b/components/script/dom/window.rs index 8494e2f4f16..37f65f774b2 100644 --- a/components/script/dom/window.rs +++ b/components/script/dom/window.rs @@ -116,7 +116,7 @@ use timers::{IsInterval, TimerCallback}; use tinyfiledialogs::{self, MessageBoxIcon}; use url::Position; use webdriver_handlers::jsval_to_webdriver; -use webrender_api::{ExternalScrollId, DocumentId}; +use webrender_api::{ExternalScrollId, DeviceIntPoint, DeviceUintSize, DocumentId}; use webvr_traits::WebVRMsg; /// Current state of the window object @@ -1180,7 +1180,7 @@ impl Window { } fn client_window(&self) -> (TypedSize2D, TypedPoint2D) { - let (send, recv) = ipc::channel::<(TypedSize2D, TypedPoint2D)>().unwrap(); + let (send, recv) = ipc::channel::<(DeviceUintSize, DeviceIntPoint)>().unwrap(); self.send_to_constellation(ScriptMsg::GetClientWindow(send)); let (size, point) = recv.recv().unwrap_or((TypedSize2D::zero(), TypedPoint2D::zero())); let dpr = self.device_pixel_ratio(); diff --git a/components/script_traits/lib.rs b/components/script_traits/lib.rs index e51e49865bc..c65ad10be4b 100644 --- a/components/script_traits/lib.rs +++ b/components/script_traits/lib.rs @@ -69,7 +69,7 @@ use style_traits::CSSPixel; use style_traits::SpeculativePainter; use style_traits::cursor::CursorKind; use webdriver_msg::{LoadStatus, WebDriverScriptCommand}; -use webrender_api::{ExternalScrollId, DevicePixel, DocumentId, ImageKey}; +use webrender_api::{ExternalScrollId, DevicePixel, DeviceUintSize, DocumentId, ImageKey}; use webvr_traits::{WebVREvent, WebVRMsg}; pub use script_msg::{LayoutMsg, ScriptMsg, EventResult, LogEntry}; @@ -650,7 +650,7 @@ pub enum WebDriverCommandMsg { /// Act as if keys were pressed in the browsing context with the given ID. SendKeys(BrowsingContextId, Vec<(Key, KeyModifiers, KeyState)>), /// Set the window size. - SetWindowSize(TopLevelBrowsingContextId, TypedSize2D, IpcSender), + SetWindowSize(TopLevelBrowsingContextId, DeviceUintSize, IpcSender), /// Take a screenshot of the window. TakeScreenshot(TopLevelBrowsingContextId, IpcSender>), } diff --git a/components/script_traits/script_msg.rs b/components/script_traits/script_msg.rs index 1d524b89710..153adbd98fe 100644 --- a/components/script_traits/script_msg.rs +++ b/components/script_traits/script_msg.rs @@ -13,7 +13,7 @@ use WorkerGlobalScopeInit; use WorkerScriptLoadOrigin; use canvas_traits::canvas::CanvasMsg; use devtools_traits::{ScriptToDevtoolsControlMsg, WorkerId}; -use euclid::{Size2D, TypedPoint2D, TypedSize2D}; +use euclid::{Size2D, TypedSize2D}; use gfx_traits::Epoch; use ipc_channel::ipc::{IpcReceiver, IpcSender}; use msg::constellation_msg::{BrowsingContextId, PipelineId, TraversalDirection}; @@ -23,9 +23,10 @@ use net_traits::request::RequestInit; use net_traits::storage_thread::StorageType; use servo_url::ImmutableOrigin; use servo_url::ServoUrl; -use style_traits::{DevicePixel, CSSPixel}; +use style_traits::CSSPixel; use style_traits::cursor::CursorKind; use style_traits::viewport::ViewportConstraints; +use webrender_api::{DeviceIntPoint, DeviceUintSize}; /// Messages from the layout to the constellation. #[derive(Deserialize, Serialize)] @@ -136,11 +137,11 @@ pub enum ScriptMsg { /// Send a key event SendKeyEvent(Option, Key, KeyState, KeyModifiers), /// Get Window Informations size and position - GetClientWindow(IpcSender<(TypedSize2D, TypedPoint2D)>), + GetClientWindow(IpcSender<(DeviceUintSize, DeviceIntPoint)>), /// Move the window to a point - MoveTo(TypedPoint2D), + MoveTo(DeviceIntPoint), /// Resize the window to size - ResizeTo(TypedSize2D), + ResizeTo(DeviceUintSize), /// Script has handled a touch event, and either prevented or allowed default actions. TouchEventProcessed(EventResult), /// A log entry, with the top-level browsing context id and thread name @@ -155,9 +156,9 @@ pub enum ScriptMsg { /// Enter or exit fullscreen SetFullscreenState(bool), /// Get the screen size (pixel) - GetScreenSize(IpcSender<(TypedSize2D)>), + GetScreenSize(IpcSender<(DeviceUintSize)>), /// Get the available screen size (pixel) - GetScreenAvailSize(IpcSender<(TypedSize2D)>), + GetScreenAvailSize(IpcSender<(DeviceUintSize)>), /// Requests that the compositor shut down. Exit, } diff --git a/ports/servo/glutin_app/window.rs b/ports/servo/glutin_app/window.rs index 2893c2eff6d..b472ca5b0ab 100644 --- a/ports/servo/glutin_app/window.rs +++ b/ports/servo/glutin_app/window.rs @@ -40,7 +40,7 @@ use style_traits::cursor::CursorKind; use tinyfiledialogs; #[cfg(target_os = "windows")] use user32; -use webrender_api::{DeviceUintRect, DeviceUintSize, ScrollLocation}; +use webrender_api::{DeviceIntPoint, DeviceUintRect, DeviceUintSize, ScrollLocation}; #[cfg(target_os = "windows")] use winapi; use winit; @@ -222,8 +222,7 @@ impl Window { pub fn new(is_foreground: bool, window_size: TypedSize2D) -> Rc { - let win_size: TypedSize2D = - (window_size.to_f32() * window_creation_scale_factor()).to_u32(); + let win_size: DeviceUintSize = (window_size.to_f32() * window_creation_scale_factor()).to_u32(); let width = win_size.to_untyped().width; let height = win_size.to_untyped().height; @@ -882,7 +881,7 @@ impl WindowMethods for Window { self.inner_size.get().to_f32() * self.hidpi_factor() } - fn client_window(&self, _: BrowserId) -> (TypedSize2D, TypedPoint2D) { + fn client_window(&self, _: BrowserId) -> (DeviceUintSize, DeviceIntPoint) { let (size, point) = match self.kind { WindowKind::Window(ref window, ..) => { // TODO(ajeffrey): can this fail? @@ -903,11 +902,11 @@ impl WindowMethods for Window { ((size * dpr).to_u32(), (point * dpr).to_i32()) } - fn screen_size(&self, _: BrowserId) -> TypedSize2D { + fn screen_size(&self, _: BrowserId) -> DeviceUintSize { (self.screen_size.to_f32() * self.hidpi_factor()).to_u32() } - fn screen_avail_size(&self, browser_id: BrowserId) -> TypedSize2D { + fn screen_avail_size(&self, browser_id: BrowserId) -> DeviceUintSize { // FIXME: Glutin doesn't have API for available size. Fallback to screen size self.screen_size(browser_id) } @@ -916,7 +915,7 @@ impl WindowMethods for Window { self.animation_state.set(state); } - fn set_inner_size(&self, _: BrowserId, size: TypedSize2D) { + fn set_inner_size(&self, _: BrowserId, size: DeviceUintSize) { match self.kind { WindowKind::Window(ref window, ..) => { let size = size.to_f32() / self.hidpi_factor(); @@ -926,7 +925,7 @@ impl WindowMethods for Window { } } - fn set_position(&self, _: BrowserId, point: TypedPoint2D) { + fn set_position(&self, _: BrowserId, point: DeviceIntPoint) { match self.kind { WindowKind::Window(ref window, ..) => { let point = point.to_f32() / self.hidpi_factor();