Merge pull request #3173 from mrobinson/typed-units-1

Start using more typed units in the compositor

src/components/compositing/compositor.rs

@@ -27,6 +27,7 @@ use geom::rect::Rect;
 use geom::size::TypedSize2D;
 use geom::scale_factor::ScaleFactor;
 use gfx::render_task::{RenderChan, RenderMsg, RenderRequest, UnusedBufferMsg};
+use layers::geometry::DevicePixel;
 use layers::layers::{BufferRequest, Layer, LayerBufferSet};
 use layers::rendergl;
 use layers::rendergl::RenderContext;
@@ -38,7 +39,7 @@ use servo_msg::compositor_msg::{LayerId, ReadyState, RenderState};
 use servo_msg::constellation_msg::{ConstellationChan, ExitMsg, LoadUrlMsg, NavigateMsg};
 use servo_msg::constellation_msg::{PipelineId, ResizedWindowMsg, WindowSizeData};
 use servo_msg::constellation_msg;
-use servo_util::geometry::{DevicePixel, PagePx, ScreenPx, ViewportPx};
+use servo_util::geometry::{PagePx, ScreenPx, ViewportPx};
 use servo_util::memory::MemoryProfilerChan;
 use servo_util::opts::Opts;
 use servo_util::time::{profile, TimeProfilerChan};
@@ -506,7 +507,7 @@ impl IOCompositor {
                     events::move(root_layer.clone(),
                                  pipeline_id,
                                  layer_id,
-                                 fragment_point,
+                                 Point2D::from_untyped(&fragment_point),
                                  window_size)
                 })
             }
@@ -522,6 +523,7 @@ impl IOCompositor {
                            new_rect_in_page_coordinates: Rect<f32>) {
         let new_rect_in_layer_coordinates =
             self.convert_page_rect_to_layer_coordinates(new_rect_in_page_coordinates);
+        let new_rect_in_layer_coordinates = Rect::from_untyped(&new_rect_in_layer_coordinates);
 
         match self.find_layer_with_pipeline_and_layer_id(pipeline_id, layer_id) {
             Some(ref layer) => *layer.bounds.borrow_mut() = new_rect_in_layer_coordinates,
@@ -571,7 +573,7 @@ impl IOCompositor {
                  events::move(layer.clone(),
                               pipeline_id,
                               layer_id,
-                              device_point,
+                              Point2D::from_untyped(&device_point),
                               window_size))
             }
             Some(_) | None => {
@@ -679,9 +681,9 @@ impl IOCompositor {
     fn on_mouse_window_event_class(&self, mouse_window_event: MouseWindowEvent) {
         let scale = self.device_pixels_per_page_px();
         let point = match mouse_window_event {
-            MouseWindowClickEvent(_, p) => p / scale,
+            MouseWindowClickEvent(_, p) => p,
-            MouseWindowMouseDownEvent(_, p) => p / scale,
+            MouseWindowMouseDownEvent(_, p) => p,
-            MouseWindowMouseUpEvent(_, p) => p / scale,
+            MouseWindowMouseUpEvent(_, p) => p,
         };
         for layer in self.scene.root.iter() {
             events::send_mouse_event(layer.clone(), mouse_window_event, point, scale);
@@ -828,8 +830,7 @@ impl IOCompositor {
     fn send_buffer_requests_for_all_layers(&mut self) {
         let mut layers_and_requests = Vec::new();
         self.scene.get_buffer_requests(&mut layers_and_requests,
-                                       Rect(Point2D(0f32, 0f32),
+                                       Rect(TypedPoint2D(0f32, 0f32), self.window_size.as_f32()));
-                                            self.window_size.as_f32().to_untyped()));
 
         // Return unused tiles first, so that they can be reused by any new BufferRequests.
         self.send_back_unused_buffers();

src/components/compositing/compositor_data.rs

@@ -9,13 +9,14 @@ use pipeline::CompositionPipeline;
 use azure::azure_hl::Color;
 use geom::point::TypedPoint2D;
 use geom::size::{Size2D, TypedSize2D};
+use geom::rect::Rect;
 use gfx::render_task::UnusedBufferMsg;
+use layers::geometry::DevicePixel;
 use layers::layers::{Layer, LayerBufferSet};
 use layers::platform::surface::NativeSurfaceMethods;
 use servo_msg::compositor_msg::{Epoch, LayerId};
 use servo_msg::compositor_msg::ScrollPolicy;
 use servo_msg::constellation_msg::PipelineId;
-use servo_util::geometry::DevicePixel;
 use std::rc::Rc;
 
 pub struct CompositorData {
@@ -59,19 +60,21 @@ impl CompositorData {
             background_color: layer_properties.background_color,
             epoch: layer_properties.epoch,
         };
-        Rc::new(Layer::new(layer_properties.rect, tile_size, new_compositor_data))
+
+        Rc::new(Layer::new(Rect::from_untyped(&layer_properties.rect),
+                           tile_size, new_compositor_data))
     }
 
     pub fn update_layer(layer: Rc<Layer<CompositorData>>, layer_properties: LayerProperties) {
         layer.extra_data.borrow_mut().epoch = layer_properties.epoch;
         layer.extra_data.borrow_mut().background_color = layer_properties.background_color;
 
-        layer.resize(layer_properties.rect.size);
+        let size: TypedSize2D<DevicePixel, f32> = Size2D::from_untyped(&layer_properties.rect.size);
+        layer.resize(size);
         layer.contents_changed();
 
         // Call scroll for bounds checking if the page shrunk. Use (-1, -1) as the
         // cursor position to make sure the scroll isn't propagated downwards.
-        let size: TypedSize2D<DevicePixel, f32> = Size2D::from_untyped(&layer.bounds.borrow().size);
         events::handle_scroll_event(layer.clone(),
                                     TypedPoint2D(0f32, 0f32),
                                     TypedPoint2D(-1f32, -1f32),

src/components/compositing/events.rs

@@ -6,16 +6,17 @@ use compositor_data::{CompositorData, WantsScrollEvents};
 use windowing::{MouseWindowEvent, MouseWindowClickEvent, MouseWindowMouseDownEvent};
 use windowing::MouseWindowMouseUpEvent;
 
-use geom::point::{Point2D, TypedPoint2D};
+use geom::length::Length;
-use geom::rect::{Rect, TypedRect};
+use geom::point::TypedPoint2D;
 use geom::scale_factor::ScaleFactor;
-use geom::size::{Size2D, TypedSize2D};
+use geom::size::TypedSize2D;
+use layers::geometry::DevicePixel;
 use layers::layers::Layer;
 use script_traits::{ClickEvent, MouseDownEvent, MouseMoveEvent, MouseUpEvent, SendEventMsg};
 use script_traits::{ScriptControlChan};
 use servo_msg::compositor_msg::{FixedPosition, LayerId};
 use servo_msg::constellation_msg::PipelineId;
-use servo_util::geometry::{DevicePixel, PagePx};
+use servo_util::geometry::PagePx;
 use std::rc::Rc;
 
 
@@ -55,36 +56,33 @@ pub fn handle_scroll_event(layer: Rc<Layer<CompositorData>>,
     }
 
     // Allow children to scroll.
-    let content_offset: TypedPoint2D<DevicePixel, f32> =
+    let content_offset = layer.content_offset.borrow().clone();
-        Point2D::from_untyped(&*layer.content_offset.borrow());
     let cursor = cursor - content_offset;
     for child in layer.children().iter() {
-        let rect: TypedRect<DevicePixel, f32> = Rect::from_untyped(&*child.bounds.borrow());
+        let child_bounds = child.bounds.borrow();
-        if rect.contains(&cursor) &&
+        if child_bounds.contains(&cursor) &&
            handle_scroll_event(child.clone(),
                                delta,
-                               cursor - rect.origin,
+                               cursor - child_bounds.origin,
-                               rect.size) {
+                               child_bounds.size) {
             return true
         }
     }
 
-    clamp_scroll_offset_and_scroll_layer(layer,
+    clamp_scroll_offset_and_scroll_layer(layer, content_offset + delta, window_size)
-                                         content_offset.to_untyped() + delta.to_untyped(),
-                                         window_size.to_untyped())
 
 }
 
 pub fn clamp_scroll_offset_and_scroll_layer(layer: Rc<Layer<CompositorData>>,
-                                            mut new_offset: Point2D<f32>,
+                                            mut new_offset: TypedPoint2D<DevicePixel, f32>,
-                                            window_size: Size2D<f32>)
+                                            window_size: TypedSize2D<DevicePixel, f32>)
                                             -> bool {
     let layer_size = layer.bounds.borrow().size;
-    let min_x = (window_size.width - layer_size.width).min(0.0);
+    let min_x = (window_size.width - layer_size.width).get().min(0.0);
-    new_offset.x = new_offset.x.clamp(&min_x, &0.0);
+    new_offset.x = Length(new_offset.x.get().clamp(&min_x, &0.0));
 
-    let min_y = (window_size.height - layer_size.height).min(0.0);
+    let min_y = (window_size.height - layer_size.height).get().min(0.0);
-    new_offset.y = new_offset.y.clamp(&min_y, &0.0);
+    new_offset.y = Length(new_offset.y.get().clamp(&min_y, &0.0));
 
     if *layer.content_offset.borrow() == new_offset {
         return false
@@ -97,13 +95,15 @@ pub fn clamp_scroll_offset_and_scroll_layer(layer: Rc<Layer<CompositorData>>,
 }
 
 fn scroll_layer_and_all_child_layers(layer: Rc<Layer<CompositorData>>,
-                                     new_offset: Point2D<f32>)
+                                     new_offset: TypedPoint2D<DevicePixel, f32>)
                                      -> bool {
     let mut result = false;
 
     // Only scroll this layer if it's not fixed-positioned.
     if layer.extra_data.borrow().scroll_policy != FixedPosition {
-        *layer.transform.borrow_mut() = identity().translate(new_offset.x, new_offset.y, 0.0);
+        *layer.transform.borrow_mut() = identity().translate(new_offset.x.get(),
+                                                             new_offset.y.get(),
+                                                             0.0);
         *layer.content_offset.borrow_mut() = new_offset;
         result = true
     }
@@ -120,20 +120,22 @@ fn scroll_layer_and_all_child_layers(layer: Rc<Layer<CompositorData>>,
 // page coordinates.
 pub fn send_mouse_event(layer: Rc<Layer<CompositorData>>,
                         event: MouseWindowEvent,
-                        cursor: TypedPoint2D<PagePx, f32>,
+                        cursor: TypedPoint2D<DevicePixel, f32>,
                         device_pixels_per_page_px: ScaleFactor<PagePx, DevicePixel, f32>) {
-    let content_offset : TypedPoint2D<DevicePixel, f32> =
+    let cursor = cursor - *layer.content_offset.borrow();
-        Point2D::from_untyped(&*layer.content_offset.borrow());
-    let cursor = cursor - (content_offset / device_pixels_per_page_px);
     for child in layer.children().iter() {
-        let rect: TypedRect<PagePx, f32> = Rect::from_untyped(&*child.bounds.borrow());
+        let child_bounds = child.bounds.borrow();
-        if rect.contains(&cursor) {
+        if child_bounds.contains(&cursor) {
-            send_mouse_event(child.clone(), event, cursor - rect.origin, device_pixels_per_page_px);
+            send_mouse_event(child.clone(),
+                             event,
+                             cursor - child_bounds.origin,
+                             device_pixels_per_page_px);
             return;
         }
     }
 
     // This mouse event is mine!
+    let cursor = cursor / device_pixels_per_page_px;
     let message = match event {
         MouseWindowClickEvent(button, _) => ClickEvent(button, cursor.to_untyped()),
         MouseWindowMouseDownEvent(button, _) => MouseDownEvent(button, cursor.to_untyped()),
@@ -153,7 +155,7 @@ pub fn send_mouse_move_event(layer: Rc<Layer<CompositorData>>,
 pub fn move(layer: Rc<Layer<CompositorData>>,
             pipeline_id: PipelineId,
             layer_id: LayerId,
-            origin: Point2D<f32>,
+            origin: TypedPoint2D<DevicePixel, f32>,
             window_size: TypedSize2D<DevicePixel, f32>)
             -> bool {
     // Search children for the right layer to move.
@@ -172,5 +174,5 @@ pub fn move(layer: Rc<Layer<CompositorData>>,
         return false
     }
 
-    clamp_scroll_offset_and_scroll_layer(layer, origin * -1.0, window_size.to_untyped())
+    clamp_scroll_offset_and_scroll_layer(layer, TypedPoint2D(0f32, 0f32) - origin, window_size)
 }

src/components/compositing/platform/common/glfw_windowing.rs

@@ -22,9 +22,10 @@ use std::rc::Rc;
 use geom::point::{Point2D, TypedPoint2D};
 use geom::scale_factor::ScaleFactor;
 use geom::size::TypedSize2D;
+use layers::geometry::DevicePixel;
 use servo_msg::compositor_msg::{IdleRenderState, RenderState, RenderingRenderState};
 use servo_msg::compositor_msg::{FinishedLoading, Blank, Loading, PerformingLayout, ReadyState};
-use servo_util::geometry::{ScreenPx, DevicePixel};
+use servo_util::geometry::ScreenPx;
 
 use glfw;
 use glfw::Context;

src/components/compositing/platform/common/glut_windowing.rs

@@ -17,9 +17,10 @@ use std::rc::Rc;
 use geom::point::{Point2D, TypedPoint2D};
 use geom::scale_factor::ScaleFactor;
 use geom::size::TypedSize2D;
+use layers::geometry::DevicePixel;
 use servo_msg::compositor_msg::{IdleRenderState, RenderState, RenderingRenderState};
 use servo_msg::compositor_msg::{FinishedLoading, Blank, ReadyState};
-use servo_util::geometry::{ScreenPx, DevicePixel};
+use servo_util::geometry::ScreenPx;
 
 use glut::glut::{ACTIVE_SHIFT, DOUBLE, WindowHeight};
 use glut::glut::WindowWidth;

src/components/compositing/windowing.rs

@@ -7,8 +7,9 @@
 use geom::point::TypedPoint2D;
 use geom::scale_factor::ScaleFactor;
 use geom::size::TypedSize2D;
+use layers::geometry::DevicePixel;
 use servo_msg::compositor_msg::{ReadyState, RenderState};
-use servo_util::geometry::{ScreenPx, DevicePixel};
+use servo_util::geometry::ScreenPx;
 use std::rc::Rc;
 
 pub enum MouseWindowEvent {

src/components/msg/constellation_msg.rs

@@ -8,8 +8,9 @@
 use geom::rect::Rect;
 use geom::size::TypedSize2D;
 use geom::scale_factor::ScaleFactor;
+use layers::geometry::DevicePixel;
 use serialize::Encodable;
-use servo_util::geometry::{DevicePixel, PagePx, ViewportPx};
+use servo_util::geometry::{PagePx, ViewportPx};
 use std::comm::{channel, Sender, Receiver};
 use url::Url;
 

src/components/util/geometry.rs

@@ -13,12 +13,6 @@ use std::fmt;
 
 // Units for use with geom::length and geom::scale_factor.
 
-/// One hardware pixel.
-///
-/// This unit corresponds to the smallest addressable element of the display hardware.
-#[deriving(Encodable)]
-pub enum DevicePixel {}
-
 /// 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

src/components/util/opts.rs

@@ -5,11 +5,12 @@
 //! Configuration options for a single run of the servo application. Created
 //! from command line arguments.
 
-use geometry::{DevicePixel, ScreenPx};
+use geometry::ScreenPx;
 
 use azure::azure_hl::{BackendType, CairoBackend, CoreGraphicsBackend};
 use azure::azure_hl::{CoreGraphicsAcceleratedBackend, Direct2DBackend, SkiaBackend};
 use geom::scale_factor::ScaleFactor;
+use layers::geometry::DevicePixel;
 use getopts;
 use std::cmp;
 use std::io;

src/components/util/util.rs

@@ -18,6 +18,7 @@ extern crate azure;
 extern crate collections;
 extern crate geom;
 extern crate getopts;
+extern crate layers;
 extern crate libc;
 extern crate native;
 extern crate rand;

src/support/layers/rust-layers

@@ -1 +1 @@
-Subproject commit 5c167a7f739553dff01d3d6cba25e344058f77a1
+Subproject commit c04029907be1f2242d48235d3b03608b905bbd9f