diff options
| author | Corey Farwell <coreyf@rwell.org> | 2015-06-11 20:51:07 -0700 |
|---|---|---|
| committer | Corey Farwell <coreyf@rwell.org> | 2015-06-13 12:28:21 -0700 |
| commit | 5c408d2be92374b2dfce0686339e132ff4cf0e4c (patch) | |
| tree | 1b8b3155610994fe31a749e997819252c5b47a56 | |
| parent | a9aa50683fec9ade7969e1ed29a9bc21d798f97e (diff) | |
| download | servo-5c408d2be92374b2dfce0686339e132ff4cf0e4c.tar.gz servo-5c408d2be92374b2dfce0686339e132ff4cf0e4c.zip | |
rust-geom API changes
https://github.com/servo/rust-geom/pull/81
39 files changed, 397 insertions, 377 deletions
diff --git a/components/canvas/canvas_paint_task.rs b/components/canvas/canvas_paint_task.rs index db149cfccd3..ca5afcbdab5 100644 --- a/components/canvas/canvas_paint_task.rs +++ b/components/canvas/canvas_paint_task.rs @@ -29,7 +29,7 @@ impl<'a> CanvasPaintTask<'a> { fn read_pixels(&self, read_rect: Rect<f64>, canvas_size: Size2D<f64>) -> Vec<u8>{ let read_rect = read_rect.to_i32(); let canvas_size = canvas_size.to_i32(); - let canvas_rect = Rect(Point2D(0i32, 0i32), canvas_size); + let canvas_rect = Rect::new(Point2D::new(0i32, 0i32), canvas_size); let src_read_rect = canvas_rect.intersection(&read_rect).unwrap_or(Rect::zero()); let mut image_data = Vec::new(); @@ -147,7 +147,7 @@ impl<'a> CanvasPaintTask<'a> { if imagedata.len() == 0 { return } - let image_rect = Rect(Point2D(0f64, 0f64), image_size); + let image_rect = Rect::new(Point2D::new(0f64, 0f64), image_size); // rgba -> bgra byte_swap(&mut imagedata); self.write_pixels(&imagedata, image_size, image_rect, dest_rect, smoothing_enabled); @@ -301,15 +301,15 @@ impl<'a> CanvasPaintTask<'a> { } fn fill_rect(&self, rect: &Rect<f32>) { - let draw_rect = Rect(rect.origin, + let draw_rect = Rect::new(rect.origin, match self.state.fill_style { Pattern::Surface(ref surface) => { let surface_size = surface.size(); match (surface.repeat_x, surface.repeat_y) { (true, true) => rect.size, - (true, false) => Size2D(rect.size.width, surface_size.height as f32), - (false, true) => Size2D(surface_size.width as f32, rect.size.height), - (false, false) => Size2D(surface_size.width as f32, surface_size.height as f32), + (true, false) => Size2D::new(rect.size.width, surface_size.height as f32), + (false, true) => Size2D::new(surface_size.width as f32, rect.size.height), + (false, false) => Size2D::new(surface_size.width as f32, surface_size.height as f32), } }, _ => rect.size, @@ -398,11 +398,11 @@ impl<'a> CanvasPaintTask<'a> { } fn rect(&self, rect: &Rect<f32>) { - self.path_builder.move_to(Point2D(rect.origin.x, rect.origin.y)); - self.path_builder.line_to(Point2D(rect.origin.x + rect.size.width, rect.origin.y)); - self.path_builder.line_to(Point2D(rect.origin.x + rect.size.width, - rect.origin.y + rect.size.height)); - self.path_builder.line_to(Point2D(rect.origin.x, rect.origin.y + rect.size.height)); + self.path_builder.move_to(Point2D::new(rect.origin.x, rect.origin.y)); + self.path_builder.line_to(Point2D::new(rect.origin.x + rect.size.width, rect.origin.y)); + self.path_builder.line_to(Point2D::new(rect.origin.x + rect.size.width, + rect.origin.y + rect.size.height)); + self.path_builder.line_to(Point2D::new(rect.origin.x, rect.origin.y + rect.size.height)); self.path_builder.close(); } @@ -462,12 +462,12 @@ impl<'a> CanvasPaintTask<'a> { // first tangent point let anx = (cp1.x - cp0.x) / a2.sqrt(); let any = (cp1.y - cp0.y) / a2.sqrt(); - let tp1 = Point2D::<AzFloat>(cp1.x - anx * d, cp1.y - any * d); + let tp1 = Point2D::new(cp1.x - anx * d, cp1.y - any * d); // second tangent point let bnx = (cp1.x - cp2.x) / b2.sqrt(); let bny = (cp1.y - cp2.y) / b2.sqrt(); - let tp2 = Point2D::<AzFloat>(cp1.x - bnx * d, cp1.y - bny * d); + let tp2 = Point2D::new(cp1.x - bnx * d, cp1.y - bny * d); // arc center and angles let anticlockwise = direction < 0.0; @@ -478,7 +478,7 @@ impl<'a> CanvasPaintTask<'a> { self.line_to(&tp1); if [cx, cy, angle_start, angle_end].iter().all(|x| x.is_finite()) { - self.arc(&Point2D::<AzFloat>(cx, cy), radius, + self.arc(&Point2D::new(cx, cy), radius, angle_start, angle_end, anticlockwise); } } @@ -577,8 +577,8 @@ impl<'a> CanvasPaintTask<'a> { // rgba -> bgra byte_swap(&mut imagedata); - let image_rect = Rect(Point2D(0f64, 0f64), - Size2D(image_data_rect.size.width, image_data_rect.size.height)); + let image_rect = Rect::new(Point2D::new(0f64, 0f64), + Size2D::new(image_data_rect.size.width, image_data_rect.size.height)); // Dirty rectangle defines the area of the source image to be copied // on the destination canvas @@ -602,10 +602,10 @@ impl<'a> CanvasPaintTask<'a> { // data structure's Canvas Pixel ArrayBuffer to the pixel with coordinate // (dx+x, dy+y) in the rendering context's scratch bitmap. // It also clips the destination rectangle to the canvas area - let dest_rect = Rect( - Point2D(image_data_rect.origin.x + source_rect.origin.x, - image_data_rect.origin.y + source_rect.origin.y), - Size2D(source_rect.size.width, source_rect.size.height)); + let dest_rect = Rect::new( + Point2D::new(image_data_rect.origin.x + source_rect.origin.x, + image_data_rect.origin.y + source_rect.origin.y), + Size2D::new(source_rect.size.width, source_rect.size.height)); self.write_pixels(&imagedata, image_data_rect.size, source_rect, dest_rect, true) } @@ -664,8 +664,8 @@ pub trait SizeToi32 { impl SizeToi32 for Size2D<f64> { fn to_i32(&self) -> Size2D<i32> { - Size2D(self.width.to_i32().unwrap(), - self.height.to_i32().unwrap()) + Size2D::new(self.width.to_i32().unwrap(), + self.height.to_i32().unwrap()) } } @@ -676,17 +676,17 @@ pub trait RectToi32 { impl RectToi32 for Rect<f64> { fn to_i32(&self) -> Rect<i32> { - Rect(Point2D(self.origin.x.to_i32().unwrap(), - self.origin.y.to_i32().unwrap()), - Size2D(self.size.width.to_i32().unwrap(), - self.size.height.to_i32().unwrap())) + Rect::new(Point2D::new(self.origin.x.to_i32().unwrap(), + self.origin.y.to_i32().unwrap()), + Size2D::new(self.size.width.to_i32().unwrap(), + self.size.height.to_i32().unwrap())) } fn ceil(&self) -> Rect<f64> { - Rect(Point2D(self.origin.x.ceil(), - self.origin.y.ceil()), - Size2D(self.size.width.ceil(), - self.size.height.ceil())) + Rect::new(Point2D::new(self.origin.x.ceil(), + self.origin.y.ceil()), + Size2D::new(self.size.width.ceil(), + self.size.height.ceil())) } } @@ -697,7 +697,7 @@ pub trait ToAzFloat { impl ToAzFloat for Rect<f64> { fn to_azfloat(&self) -> Rect<AzFloat> { - Rect(Point2D(self.origin.x as AzFloat, self.origin.y as AzFloat), - Size2D(self.size.width as AzFloat, self.size.height as AzFloat)) + Rect::new(Point2D::new(self.origin.x as AzFloat, self.origin.y as AzFloat), + Size2D::new(self.size.width as AzFloat, self.size.height as AzFloat)) } } diff --git a/components/canvas_traits/lib.rs b/components/canvas_traits/lib.rs index dcf27baeea1..7da9dc7d8af 100644 --- a/components/canvas_traits/lib.rs +++ b/components/canvas_traits/lib.rs @@ -224,8 +224,8 @@ impl FillOrStrokeStyle { }).collect(); Pattern::LinearGradient(LinearGradientPattern::new( - &Point2D(linear_gradient_style.x0 as AzFloat, linear_gradient_style.y0 as AzFloat), - &Point2D(linear_gradient_style.x1 as AzFloat, linear_gradient_style.y1 as AzFloat), + &Point2D::new(linear_gradient_style.x0 as AzFloat, linear_gradient_style.y0 as AzFloat), + &Point2D::new(linear_gradient_style.x1 as AzFloat, linear_gradient_style.y1 as AzFloat), drawtarget.create_gradient_stops(&gradient_stops, ExtendMode::Clamp), &Matrix2D::identity())) }, @@ -238,8 +238,8 @@ impl FillOrStrokeStyle { }).collect(); Pattern::RadialGradient(RadialGradientPattern::new( - &Point2D(radial_gradient_style.x0 as AzFloat, radial_gradient_style.y0 as AzFloat), - &Point2D(radial_gradient_style.x1 as AzFloat, radial_gradient_style.y1 as AzFloat), + &Point2D::new(radial_gradient_style.x0 as AzFloat, radial_gradient_style.y0 as AzFloat), + &Point2D::new(radial_gradient_style.x1 as AzFloat, radial_gradient_style.y1 as AzFloat), radial_gradient_style.r0 as AzFloat, radial_gradient_style.r1 as AzFloat, drawtarget.create_gradient_stops(&gradient_stops, ExtendMode::Clamp), &Matrix2D::identity())) diff --git a/components/compositing/compositor.rs b/components/compositing/compositor.rs index 7a1914bbbb9..0e668f2717c 100644 --- a/components/compositing/compositor.rs +++ b/components/compositing/compositor.rs @@ -699,7 +699,7 @@ impl<Window: WindowMethods> IOCompositor<Window> { match self.find_layer_with_pipeline_and_layer_id(pipeline_id, layer_id) { Some(ref layer) => { if layer.wants_scroll_events() == WantsScrollEventsFlag::WantsScrollEvents { - layer.clamp_scroll_offset_and_scroll_layer(TypedPoint2D(0f32, 0f32) - origin); + layer.clamp_scroll_offset_and_scroll_layer(Point2D::typed(0f32, 0f32) - origin); } true } @@ -957,14 +957,14 @@ impl<Window: WindowMethods> IOCompositor<Window> { window_size: &TypedSize2D<LayerPixel, f32>, new_display_ports: &mut HashMap<PipelineId, Vec<(LayerId, Rect<Au>)>>) { let visible_rect = - Rect(Point2D::zero(), *window_size).translate(&-*layer.content_offset.borrow()) - .intersection(&*layer.bounds.borrow()) - .unwrap_or(Rect::zero()) - .to_untyped(); - let visible_rect = Rect(Point2D(Au::from_f32_px(visible_rect.origin.x), - Au::from_f32_px(visible_rect.origin.y)), - Size2D(Au::from_f32_px(visible_rect.size.width), - Au::from_f32_px(visible_rect.size.height))); + Rect::new(Point2D::zero(), *window_size).translate(&-*layer.content_offset.borrow()) + .intersection(&*layer.bounds.borrow()) + .unwrap_or(Rect::zero()) + .to_untyped(); + let visible_rect = Rect::new(Point2D::new(Au::from_f32_px(visible_rect.origin.x), + Au::from_f32_px(visible_rect.origin.y)), + Size2D::new(Au::from_f32_px(visible_rect.size.width), + Au::from_f32_px(visible_rect.size.height))); let extra_layer_data = layer.extra_data.borrow(); if !new_display_ports.contains_key(&extra_layer_data.pipeline_id) { @@ -1087,11 +1087,11 @@ impl<Window: WindowMethods> IOCompositor<Window> { // Scroll as needed let window_size = self.window_size.as_f32(); - let page_delta: TypedPoint2D<LayerPixel, f32> = TypedPoint2D( + let page_delta: TypedPoint2D<LayerPixel, f32> = Point2D::typed( window_size.width.get() * (viewport_zoom.inv() - old_viewport_zoom.inv()).get() * 0.5, window_size.height.get() * (viewport_zoom.inv() - old_viewport_zoom.inv()).get() * 0.5); - let cursor = TypedPoint2D(-1f32, -1f32); // Make sure this hits the base layer. + let cursor = Point2D::typed(-1f32, -1f32); // Make sure this hits the base layer. match self.scene.root { Some(ref mut layer) => { layer.handle_scroll_event(page_delta, cursor); @@ -1167,8 +1167,8 @@ impl<Window: WindowMethods> IOCompositor<Window> { fn send_viewport_rect_for_layer(&self, layer: Rc<Layer<CompositorData>>) { if layer.extra_data.borrow().id == LayerId::null() { - let layer_rect = Rect(-layer.extra_data.borrow().scroll_offset.to_untyped(), - layer.bounds.borrow().size.to_untyped()); + let layer_rect = Rect::new(-layer.extra_data.borrow().scroll_offset.to_untyped(), + layer.bounds.borrow().size.to_untyped()); let pipeline = self.get_pipeline(layer.pipeline_id()); let ScriptControlChan(ref chan) = pipeline.script_chan; chan.send(ConstellationControlMsg::Viewport(pipeline.id.clone(), layer_rect)).unwrap(); @@ -1437,7 +1437,7 @@ impl<Window: WindowMethods> IOCompositor<Window> { }; let clip_rect_for_children = if masks_to_bounds { - Rect(Point2D::zero(), clipped_layer_bounds.size) + Rect::new(Point2D::zero(), clipped_layer_bounds.size) } else { clipped_layer_bounds.translate(&clip_rect.origin) }; diff --git a/components/compositing/compositor_layer.rs b/components/compositing/compositor_layer.rs index 240923410ad..133c45e9bcb 100644 --- a/components/compositing/compositor_layer.rs +++ b/components/compositing/compositor_layer.rs @@ -7,7 +7,7 @@ use windowing::{MouseWindowEvent, WindowMethods}; use azure::azure_hl; use geom::length::Length; -use geom::matrix::identity; +use geom::matrix::Matrix4; use geom::point::{Point2D, TypedPoint2D}; use geom::size::TypedSize2D; use geom::rect::Rect; @@ -59,7 +59,7 @@ impl CompositorData { scroll_policy: layer_properties.scroll_policy, requested_epoch: Epoch(0), painted_epoch: Epoch(0), - scroll_offset: TypedPoint2D(0., 0.), + scroll_offset: Point2D::typed(0., 0.), }; Rc::new(Layer::new(Rect::from_untyped(&layer_properties.rect), @@ -201,7 +201,7 @@ impl CompositorLayer for Layer<CompositorData> { // 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. - self.handle_scroll_event(TypedPoint2D(0f32, 0f32), TypedPoint2D(-1f32, -1f32)); + self.handle_scroll_event(Point2D::typed(0f32, 0f32), Point2D::typed(-1f32, -1f32)); self.update_layer_except_bounds(layer_properties); } @@ -332,8 +332,8 @@ impl CompositorLayer for Layer<CompositorData> { let min_x = (layer_size.width - content_size.width).get().min(0.0); let min_y = (layer_size.height - content_size.height).get().min(0.0); let new_offset : TypedPoint2D<LayerPixel, f32> = - Point2D(Length::new(new_offset.x.get().clamp(&min_x, &0.0)), - Length::new(new_offset.y.get().clamp(&min_y, &0.0))); + Point2D::new(Length::new(new_offset.x.get().clamp(&min_x, &0.0)), + Length::new(new_offset.y.get().clamp(&min_y, &0.0))); if self.extra_data.borrow().scroll_offset == new_offset { return ScrollEventResult::ScrollPositionUnchanged; @@ -392,7 +392,7 @@ impl CompositorLayer for Layer<CompositorData> { // Only scroll this layer if it's not fixed-positioned. if self.extra_data.borrow().scroll_policy != ScrollPolicy::FixedPosition { let new_offset = new_offset.to_untyped(); - *self.transform.borrow_mut() = identity().translate(new_offset.x, new_offset.y, 0.0); + *self.transform.borrow_mut() = Matrix4::identity().translate(new_offset.x, new_offset.y, 0.0); *self.content_offset.borrow_mut() = Point2D::from_untyped(&new_offset); result = true } diff --git a/components/compositing/constellation.rs b/components/compositing/constellation.rs index 1ff8b304216..cbca7b48a06 100644 --- a/components/compositing/constellation.rs +++ b/components/compositing/constellation.rs @@ -534,7 +534,7 @@ impl<LTF: LayoutTaskFactory, STF: ScriptTaskFactory> Constellation<LTF, STF> { } fn handle_init_load(&mut self, url: Url) { - let window_rect = Rect(Point2D::zero(), self.window_size.visible_viewport); + let window_rect = Rect::new(Point2D::zero(), self.window_size.visible_viewport); let root_pipeline_id = self.new_pipeline(None, Some(window_rect), None, LoadData::new(url.clone())); self.handle_load_start_msg(&root_pipeline_id); diff --git a/components/compositing/headless.rs b/components/compositing/headless.rs index ed3afa6a4b0..e18e1275122 100644 --- a/components/compositing/headless.rs +++ b/components/compositing/headless.rs @@ -6,7 +6,7 @@ use compositor_task::{CompositorEventListener, CompositorReceiver, Msg}; use windowing::WindowEvent; use geom::scale_factor::ScaleFactor; -use geom::size::TypedSize2D; +use geom::size::Size2D; use msg::constellation_msg::Msg as ConstellationMsg; use msg::constellation_msg::{ConstellationChan, WindowSizeData}; use profile_traits::mem; @@ -55,8 +55,8 @@ impl NullCompositor { { let ConstellationChan(ref chan) = compositor.constellation_chan; chan.send(ConstellationMsg::ResizedWindow(WindowSizeData { - initial_viewport: TypedSize2D(640_f32, 480_f32), - visible_viewport: TypedSize2D(640_f32, 480_f32), + initial_viewport: Size2D::typed(640_f32, 480_f32), + visible_viewport: Size2D::typed(640_f32, 480_f32), device_pixel_ratio: ScaleFactor::new(1.0), })).unwrap(); } diff --git a/components/gfx/display_list/mod.rs b/components/gfx/display_list/mod.rs index 74975472418..bf2c839bc7e 100644 --- a/components/gfx/display_list/mod.rs +++ b/components/gfx/display_list/mod.rs @@ -472,14 +472,13 @@ impl StackingContext { DisplayItem::BorderClass(ref border) => { // If the point is inside the border, it didn't hit the border! let interior_rect = - Rect(Point2D(border.base.bounds.origin.x + border.border_widths.left, - border.base.bounds.origin.y + border.border_widths.top), - Size2D(border.base.bounds.size.width - - (border.border_widths.left + - border.border_widths.right), - border.base.bounds.size.height - - (border.border_widths.top + - border.border_widths.bottom))); + Rect::new( + Point2D::new(border.base.bounds.origin.x + border.border_widths.left, + border.base.bounds.origin.y + border.border_widths.top), + Size2D::new(border.base.bounds.size.width - + (border.border_widths.left + border.border_widths.right), + border.base.bounds.size.height - + (border.border_widths.top + border.border_widths.bottom))); if geometry::rect_contains_point(interior_rect, point) { continue } @@ -499,9 +498,9 @@ impl StackingContext { point = point - self.bounds.origin; debug_assert!(!topmost_only || result.is_empty()); - let frac_point = self.transform.transform_point(&Point2D(point.x.to_f32_px(), + let frac_point = self.transform.transform_point(&Point2D::new(point.x.to_f32_px(), point.y.to_f32_px())); - point = Point2D(Au::from_f32_px(frac_point.x), Au::from_f32_px(frac_point.y)); + point = Point2D::new(Au::from_f32_px(frac_point.x), Au::from_f32_px(frac_point.y)); // Iterate through display items in reverse stacking order. Steps here refer to the // painting steps in CSS 2.1 Appendix E. diff --git a/components/gfx/font.rs b/components/gfx/font.rs index b8521b7b735..d06540a9657 100644 --- a/components/gfx/font.rs +++ b/components/gfx/font.rs @@ -228,8 +228,8 @@ pub struct RunMetrics { impl RunMetrics { pub fn new(advance: Au, ascent: Au, descent: Au) -> RunMetrics { - let bounds = Rect(Point2D(Au(0), -ascent), - Size2D(advance, ascent + descent)); + let bounds = Rect::new(Point2D::new(Au(0), -ascent), + Size2D::new(advance, ascent + descent)); // TODO(Issue #125): support loose and tight bounding boxes; using the // ascent+descent and advance is sometimes too generous and diff --git a/components/gfx/paint_context.rs b/components/gfx/paint_context.rs index 33efa9c1b61..16564f6e44a 100644 --- a/components/gfx/paint_context.rs +++ b/components/gfx/paint_context.rs @@ -107,11 +107,11 @@ impl<'a> PaintContext<'a> { let rect = bounds.to_nearest_azure_rect(); let path_builder = self.draw_target.create_path_builder(); - let left_top = Point2D(rect.origin.x, rect.origin.y); - let right_top = Point2D(rect.origin.x + rect.size.width, rect.origin.y); - let left_bottom = Point2D(rect.origin.x, rect.origin.y + rect.size.height); - let right_bottom = Point2D(rect.origin.x + rect.size.width, - rect.origin.y + rect.size.height); + let left_top = Point2D::new(rect.origin.x, rect.origin.y); + let right_top = Point2D::new(rect.origin.x + rect.size.width, rect.origin.y); + let left_bottom = Point2D::new(rect.origin.x, rect.origin.y + rect.size.height); + let right_bottom = Point2D::new(rect.origin.x + rect.size.width, + rect.origin.y + rect.size.height); path_builder.move_to(left_top); path_builder.line_to(right_top); @@ -130,7 +130,7 @@ impl<'a> PaintContext<'a> { bounds: &Rect<Au>, image: Arc<Image>, image_rendering: image_rendering::T) { - let size = Size2D(image.width as i32, image.height as i32); + let size = Size2D::new(image.width as i32, image.height as i32); let (pixel_width, pixels, source_format) = match image.pixels { PixelsByColorType::RGBA8(ref pixels) => (4, pixels, SurfaceFormat::B8G8R8A8), PixelsByColorType::K8(ref pixels) => (1, pixels, SurfaceFormat::A8), @@ -145,8 +145,8 @@ impl<'a> PaintContext<'a> { size, stride as i32, source_format); - let source_rect = Rect(Point2D(0.0, 0.0), - Size2D(image.width as AzFloat, image.height as AzFloat)); + let source_rect = Rect::new(Point2D::new(0.0, 0.0), + Size2D::new(image.width as AzFloat, image.height as AzFloat)); let dest_rect = bounds.to_nearest_azure_rect(); // TODO(pcwalton): According to CSS-IMAGES-3 § 5.3, nearest-neighbor interpolation is a @@ -169,10 +169,10 @@ impl<'a> PaintContext<'a> { pub fn clear(&self) { let pattern = ColorPattern::new(color::transparent()); - let rect = Rect(Point2D(self.page_rect.origin.x as AzFloat, - self.page_rect.origin.y as AzFloat), - Size2D(self.screen_rect.size.width as AzFloat, - self.screen_rect.size.height as AzFloat)); + let rect = Rect::new(Point2D::new(self.page_rect.origin.x as AzFloat, + self.page_rect.origin.y as AzFloat), + Size2D::new(self.screen_rect.size.width as AzFloat, + self.screen_rect.size.height as AzFloat)); let mut draw_options = DrawOptions::new(1.0, CompositionOp::Over, AntialiasMode::None); draw_options.set_composition_op(CompositionOp::Source); self.draw_target.make_current(); @@ -390,9 +390,9 @@ impl<'a> PaintContext<'a> { // T = top, B = bottom, L = left, R = right let box_TL = bounds.origin; - let box_TR = box_TL + Point2D(bounds.size.width, 0.0); - let box_BL = box_TL + Point2D(0.0, bounds.size.height); - let box_BR = box_TL + Point2D(bounds.size.width, bounds.size.height); + let box_TR = box_TL + Point2D::new(bounds.size.width, 0.0); + let box_BL = box_TL + Point2D::new(0.0, bounds.size.height); + let box_BR = box_TL + Point2D::new(bounds.size.width, bounds.size.height); let rad_R: AzFloat = 0.; let rad_BR = rad_R + f32::consts::FRAC_PI_4; @@ -404,19 +404,19 @@ impl<'a> PaintContext<'a> { let rad_TR = rad_T + f32::consts::FRAC_PI_4; fn dx(x: AzFloat) -> Point2D<AzFloat> { - Point2D(x, 0.) + Point2D::new(x, 0.) } fn dy(y: AzFloat) -> Point2D<AzFloat> { - Point2D(0., y) + Point2D::new(0., y) } fn dx_if(cond: bool, dx: AzFloat) -> Point2D<AzFloat> { - Point2D(if cond { dx } else { 0. }, 0.) + Point2D::new(if cond { dx } else { 0. }, 0.) } fn dy_if(cond: bool, dy: AzFloat) -> Point2D<AzFloat> { - Point2D(0., if cond { dy } else { 0. }) + Point2D::new(0., if cond { dy } else { 0. }) } match direction { @@ -434,8 +434,8 @@ impl<'a> PaintContext<'a> { if radius.top_right != 0. { // the origin is the center of the arcs we're about to draw. - let origin = edge_TR + Point2D((border.right - radius.top_right).max(0.), - radius.top_right); + let origin = edge_TR + Point2D::new((border.right - radius.top_right).max(0.), + radius.top_right); // the elbow is the inside of the border's curve. let distance_to_elbow = (radius.top_right - border.top).max(0.); @@ -447,7 +447,7 @@ impl<'a> PaintContext<'a> { path_builder.line_to(edge_BL); if radius.top_left != 0. { - let origin = edge_TL + Point2D(-(border.left - radius.top_left).max(0.), + let origin = edge_TL + Point2D::new(-(border.left - radius.top_left).max(0.), radius.top_left); let distance_to_elbow = (radius.top_left - border.top).max(0.); @@ -468,7 +468,7 @@ impl<'a> PaintContext<'a> { path_builder.line_to(corner_TL); if radius.top_left != 0. { - let origin = edge_TL + Point2D(radius.top_left, + let origin = edge_TL + Point2D::new(radius.top_left, -(border.top - radius.top_left).max(0.)); let distance_to_elbow = (radius.top_left - border.left).max(0.); @@ -481,7 +481,7 @@ impl<'a> PaintContext<'a> { if radius.bottom_left != 0. { let origin = edge_BL + - Point2D(radius.bottom_left, + Point2D::new(radius.bottom_left, (border.bottom - radius.bottom_left).max(0.)); let distance_to_elbow = (radius.bottom_left - border.left).max(0.); @@ -502,8 +502,8 @@ impl<'a> PaintContext<'a> { path_builder.line_to(edge_TL); if radius.top_right != 0. { - let origin = edge_TR + Point2D(-radius.top_right, - -(border.top - radius.top_right).max(0.)); + let origin = edge_TR + Point2D::new(-radius.top_right, + -(border.top - radius.top_right).max(0.)); let distance_to_elbow = (radius.top_right - border.right).max(0.); path_builder.arc(origin, distance_to_elbow, rad_R, rad_TR, true); @@ -515,7 +515,7 @@ impl<'a> PaintContext<'a> { if radius.bottom_right != 0. { let origin = edge_BR + - Point2D(-radius.bottom_right, + Point2D::new(-radius.bottom_right, (border.bottom - radius.bottom_right).max(0.)); let distance_to_elbow = (radius.bottom_right - border.right).max(0.); @@ -536,8 +536,8 @@ impl<'a> PaintContext<'a> { path_builder.line_to(edge_TR); if radius.bottom_right != 0. { - let origin = edge_BR + Point2D((border.right - radius.bottom_right).max(0.), - -radius.bottom_right); + let origin = edge_BR + Point2D::new((border.right - radius.bottom_right).max(0.), + -radius.bottom_right); let distance_to_elbow = (radius.bottom_right - border.bottom).max(0.); path_builder.arc(origin, distance_to_elbow, rad_B, rad_BR, true); @@ -548,7 +548,7 @@ impl<'a> PaintContext<'a> { path_builder.line_to(corner_BL); if radius.bottom_left != 0. { - let origin = edge_BL - Point2D((border.left - radius.bottom_left).max(0.), + let origin = edge_BL - Point2D::new((border.left - radius.bottom_left).max(0.), radius.bottom_left); let distance_to_elbow = (radius.bottom_left - border.bottom).max(0.); @@ -579,35 +579,35 @@ impl<'a> PaintContext<'a> { // \ 6 5 / // +----------+ - path_builder.move_to(Point2D(bounds.origin.x + radii.top_left, bounds.origin.y)); // 1 - path_builder.line_to(Point2D(bounds.max_x() - radii.top_right, bounds.origin.y)); // 2 - path_builder.arc(Point2D(bounds.max_x() - radii.top_right, - bounds.origin.y + radii.top_right), + path_builder.move_to(Point2D::new(bounds.origin.x + radii.top_left, bounds.origin.y)); // 1 + path_builder.line_to(Point2D::new(bounds.max_x() - radii.top_right, bounds.origin.y)); // 2 + path_builder.arc(Point2D::new(bounds.max_x() - radii.top_right, + bounds.origin.y + radii.top_right), radii.top_right, 1.5f32 * f32::consts::FRAC_PI_2, f32::consts::PI_2, - false); // 3 - path_builder.line_to(Point2D(bounds.max_x(), bounds.max_y() - radii.bottom_right)); // 4 - path_builder.arc(Point2D(bounds.max_x() - radii.bottom_right, - bounds.max_y() - radii.bottom_right), + false); // 3 + path_builder.line_to(Point2D::new(bounds.max_x(), bounds.max_y() - radii.bottom_right)); // 4 + path_builder.arc(Point2D::new(bounds.max_x() - radii.bottom_right, + bounds.max_y() - radii.bottom_right), radii.bottom_right, 0.0, f32::consts::FRAC_PI_2, - false); // 5 - path_builder.line_to(Point2D(bounds.origin.x + radii.bottom_left, bounds.max_y())); // 6 - path_builder.arc(Point2D(bounds.origin.x + radii.bottom_left, + false); // 5 + path_builder.line_to(Point2D::new(bounds.origin.x + radii.bottom_left, bounds.max_y())); // 6 + path_builder.arc(Point2D::new(bounds.origin.x + radii.bottom_left, bounds.max_y() - radii.bottom_left), radii.bottom_left, f32::consts::FRAC_PI_2, f32::consts::PI, - false); // 7 - path_builder.line_to(Point2D(bounds.origin.x, bounds.origin.y + radii.top_left)); // 8 - path_builder.arc(Point2D(bounds.origin.x + radii.top_left, - bounds.origin.y + radii.top_left), + false); // 7 + path_builder.line_to(Point2D::new(bounds.origin.x, bounds.origin.y + radii.top_left)); // 8 + path_builder.arc(Point2D::new(bounds.origin.x + radii.top_left, + bounds.origin.y + radii.top_left), radii.top_left, f32::consts::PI, 1.5f32 * f32::consts::FRAC_PI_2, - false); // 1 + false); // 1 } fn draw_dashed_border_segment(&self, @@ -634,26 +634,26 @@ impl<'a> PaintContext<'a> { let (start, end) = match direction { Direction::Top => { let y = rect.origin.y + border.top * 0.5; - let start = Point2D(rect.origin.x, y); - let end = Point2D(rect.origin.x + rect.size.width, y); + let start = Point2D::new(rect.origin.x, y); + let end = Point2D::new(rect.origin.x + rect.size.width, y); (start, end) } Direction::Left => { let x = rect.origin.x + border.left * 0.5; - let start = Point2D(x, rect.origin.y + rect.size.height); - let end = Point2D(x, rect.origin.y + border.top); + let start = Point2D::new(x, rect.origin.y + rect.size.height); + let end = Point2D::new(x, rect.origin.y + border.top); (start, end) } Direction::Right => { let x = rect.origin.x + rect.size.width - border.right * 0.5; - let start = Point2D(x, rect.origin.y); - let end = Point2D(x, rect.origin.y + rect.size.height); + let start = Point2D::new(x, rect.origin.y); + let end = Point2D::new(x, rect.origin.y + rect.size.height); (start, end) } Direction::Bottom => { let y = rect.origin.y + rect.size.height - border.bottom * 0.5; - let start = Point2D(rect.origin.x + rect.size.width, y); - let end = Point2D(rect.origin.x + border.left, y); + let start = Point2D::new(rect.origin.x + rect.size.width, y); + let end = Point2D::new(rect.origin.x + border.left, y); (start, end) } }; @@ -684,12 +684,12 @@ impl<'a> PaintContext<'a> { shrink_factor * border.right, shrink_factor * border.bottom, shrink_factor * border.left); - let left_top = Point2D(rect.origin.x, rect.origin.y); - let scaled_left_top = left_top + Point2D(scaled_border.left, - scaled_border.top); - return Rect(scaled_left_top, - Size2D(rect.size.width - 2.0 * scaled_border.right, - rect.size.height - 2.0 * scaled_border.bottom)); + let left_top = Point2D::new(rect.origin.x, rect.origin.y); + let scaled_left_top = left_top + Point2D::new(scaled_border.left, + scaled_border.top); + return Rect::new(scaled_left_top, + Size2D::new(rect.size.width - 2.0 * scaled_border.right, + rect.size.height - 2.0 * scaled_border.bottom)); } fn scale_color(&self, color: Color, scale_factor: f32) -> Color { @@ -906,7 +906,7 @@ impl<'a> PaintContext<'a> { // FIXME(pcwalton): This surface might be bigger than necessary and waste memory. let size = self.draw_target.get_size(); //Az size. - let mut size = Size2D(size.width, size.height); //Geom::Size. + let mut size = Size2D::new(size.width, size.height); //Geom::Size. // Pre-calculate if there is a blur expansion need. let accum_blur = filters::calculate_accumulated_blur(filters); @@ -914,13 +914,13 @@ impl<'a> PaintContext<'a> { if accum_blur > Au(0) { // Set the correct size. let side_inflation = accum_blur * BLUR_INFLATION_FACTOR; - size = Size2D(size.width + (side_inflation.to_nearest_px() * 2) as i32, - size.height + (side_inflation.to_nearest_px() * 2) as i32); + size = Size2D::new(size.width + (side_inflation.to_nearest_px() * 2) as i32, + size.height + (side_inflation.to_nearest_px() * 2) as i32); // Calculate the transform matrix. let old_transform = self.draw_target.get_transform(); - let inflated_size = Rect(Point2D(0.0, 0.0), Size2D(size.width as AzFloat, - size.height as AzFloat)); + let inflated_size = Rect::new(Point2D::new(0.0, 0.0), Size2D::new(size.width as AzFloat, + size.height as AzFloat)); let temporary_draw_target_bounds = old_transform.transform_rect(&inflated_size); matrix = Matrix2D::identity().translate( -temporary_draw_target_bounds.origin.x as AzFloat, @@ -948,9 +948,9 @@ impl<'a> PaintContext<'a> { // Set up transforms. let old_transform = self.draw_target.get_transform(); self.draw_target.set_transform(&Matrix2D::identity()); - let rect = Rect(Point2D(0.0, 0.0), self.draw_target.get_size().to_azure_size()); + let rect = Rect::new(Point2D::new(0.0, 0.0), self.draw_target.get_size().to_azure_size()); - let rect_temporary = Rect(Point2D(0.0, 0.0), temporary_draw_target.get_size().to_azure_size()); + let rect_temporary = Rect::new(Point2D::new(0.0, 0.0), temporary_draw_target.get_size().to_azure_size()); // Create the Azure filter pipeline. let mut accum_blur = Au(0); @@ -1111,10 +1111,10 @@ pub trait ToAzurePoint { impl ToAzurePoint for Point2D<Au> { fn to_nearest_azure_point(&self) -> Point2D<AzFloat> { - Point2D(self.x.to_nearest_px() as AzFloat, self.y.to_nearest_px() as AzFloat) + Point2D::new(self.x.to_nearest_px() as AzFloat, self.y.to_nearest_px() as AzFloat) } fn to_azure_point(&self) -> Point2D<AzFloat> { - Point2D(self.x.to_f32_px(), self.y.to_f32_px()) + Point2D::new(self.x.to_f32_px(), self.y.to_f32_px()) } } @@ -1125,13 +1125,13 @@ pub trait ToAzureRect { impl ToAzureRect for Rect<Au> { fn to_nearest_azure_rect(&self) -> Rect<AzFloat> { - Rect(self.origin.to_nearest_azure_point(), Size2D(self.size.width.to_nearest_px() as AzFloat, - self.size.height.to_nearest_px() as AzFloat)) + Rect::new(self.origin.to_nearest_azure_point(), Size2D::new(self.size.width.to_nearest_px() as AzFloat, + self.size.height.to_nearest_px() as AzFloat)) } fn to_azure_rect(&self) -> Rect<AzFloat> { - Rect(self.origin.to_azure_point(), Size2D(self.size.width.to_f32_px(), - self.size.height.to_f32_px())) + Rect::new(self.origin.to_azure_point(), Size2D::new(self.size.width.to_f32_px(), + self.size.height.to_f32_px())) } } @@ -1141,7 +1141,7 @@ pub trait ToAzureSize { impl ToAzureSize for AzIntSize { fn to_azure_size(&self) -> Size2D<AzFloat> { - Size2D(self.width as AzFloat, self.height as AzFloat) + Size2D::new(self.width as AzFloat, self.height as AzFloat) } } @@ -1151,19 +1151,19 @@ trait ToAzureIntSize { impl ToAzureIntSize for Size2D<Au> { fn to_azure_int_size(&self) -> Size2D<i32> { - Size2D(self.width.to_nearest_px() as i32, self.height.to_nearest_px() as i32) + Size2D::new(self.width.to_nearest_px() as i32, self.height.to_nearest_px() as i32) } } impl ToAzureIntSize for Size2D<AzFloat> { fn to_azure_int_size(&self) -> Size2D<i32> { - Size2D(self.width as i32, self.height as i32) + Size2D::new(self.width as i32, self.height as i32) } } impl ToAzureIntSize for Size2D<i32> { fn to_azure_int_size(&self) -> Size2D<i32> { - Size2D(self.width, self.height) + Size2D::new(self.width, self.height) } } @@ -1243,7 +1243,7 @@ impl ScaledFontExtensionMethods for ScaledFont { y: (origin.y + glyph_offset.y).to_f32_px(), } }; - origin = Point2D(origin.x + glyph_advance, origin.y); + origin = Point2D::new(origin.x + glyph_advance, origin.y); azglyphs.push(azglyph) }; } @@ -1306,25 +1306,25 @@ impl DrawTargetExtensions for DrawTarget { let (outer_rect, inner_rect) = (outer_rect.to_nearest_azure_rect(), inner_rect.to_nearest_azure_rect()); let path_builder = self.create_path_builder(); - path_builder.move_to(Point2D(outer_rect.max_x(), outer_rect.origin.y)); // 1 - path_builder.line_to(Point2D(outer_rect.origin.x, outer_rect.origin.y)); // 2 - path_builder.line_to(Point2D(outer_rect.origin.x, outer_rect.max_y())); // 3 - path_builder.line_to(Point2D(outer_rect.max_x(), outer_rect.max_y())); // 4 - path_builder.line_to(Point2D(outer_rect.max_x(), inner_rect.origin.y)); // 5 - path_builder.line_to(Point2D(inner_rect.max_x(), inner_rect.origin.y)); // 6 - path_builder.line_to(Point2D(inner_rect.max_x(), inner_rect.max_y())); // 7 - path_builder.line_to(Point2D(inner_rect.origin.x, inner_rect.max_y())); // 8 - path_builder.line_to(inner_rect.origin); // 9 - path_builder.line_to(Point2D(outer_rect.max_x(), inner_rect.origin.y)); // 10 + path_builder.move_to(Point2D::new(outer_rect.max_x(), outer_rect.origin.y)); // 1 + path_builder.line_to(Point2D::new(outer_rect.origin.x, outer_rect.origin.y)); // 2 + path_builder.line_to(Point2D::new(outer_rect.origin.x, outer_rect.max_y())); // 3 + path_builder.line_to(Point2D::new(outer_rect.max_x(), outer_rect.max_y())); // 4 + path_builder.line_to(Point2D::new(outer_rect.max_x(), inner_rect.origin.y)); // 5 + path_builder.line_to(Point2D::new(inner_rect.max_x(), inner_rect.origin.y)); // 6 + path_builder.line_to(Point2D::new(inner_rect.max_x(), inner_rect.max_y())); // 7 + path_builder.line_to(Point2D::new(inner_rect.origin.x, inner_rect.max_y())); // 8 + path_builder.line_to(inner_rect.origin); // 9 + path_builder.line_to(Point2D::new(outer_rect.max_x(), inner_rect.origin.y)); // 10 path_builder.finish() } fn create_rectangular_path(&self, rect: &Rect<Au>) -> Path { let path_builder = self.create_path_builder(); path_builder.move_to(rect.origin.to_nearest_azure_point()); - path_builder.line_to(Point2D(rect.max_x(), rect.origin.y).to_nearest_azure_point()); - path_builder.line_to(Point2D(rect.max_x(), rect.max_y()).to_nearest_azure_point()); - path_builder.line_to(Point2D(rect.origin.x, rect.max_y()).to_nearest_azure_point()); + path_builder.line_to(Point2D::new(rect.max_x(), rect.origin.y).to_nearest_azure_point()); + path_builder.line_to(Point2D::new(rect.max_x(), rect.max_y()).to_nearest_azure_point()); + path_builder.line_to(Point2D::new(rect.origin.x, rect.max_y()).to_nearest_azure_point()); path_builder.finish() } } @@ -1373,7 +1373,7 @@ impl TemporaryDrawTarget { fn from_main_draw_target(main_draw_target: &DrawTarget) -> TemporaryDrawTarget { TemporaryDrawTarget { draw_target: main_draw_target.clone(), - offset: Point2D(0.0, 0.0), + offset: Point2D::new(0.0, 0.0), } } @@ -1385,8 +1385,8 @@ impl TemporaryDrawTarget { let temporary_draw_target_bounds = draw_target_transform.transform_rect(&bounds.to_azure_rect()); let temporary_draw_target_size = - Size2D(temporary_draw_target_bounds.size.width.ceil() as i32, - temporary_draw_target_bounds.size.height.ceil() as i32); + Size2D::new(temporary_draw_target_bounds.size.width.ceil() as i32, + temporary_draw_target_bounds.size.height.ceil() as i32); let temporary_draw_target = main_draw_target.create_similar_draw_target(&temporary_draw_target_size, main_draw_target.get_format()); @@ -1405,14 +1405,14 @@ impl TemporaryDrawTarget { fn draw_filter(self, main_draw_target: &DrawTarget, filter: FilterNode) { let main_draw_target_transform = main_draw_target.get_transform(); let temporary_draw_target_size = self.draw_target.get_size(); - let temporary_draw_target_size = Size2D(temporary_draw_target_size.width as AzFloat, - temporary_draw_target_size.height as AzFloat); + let temporary_draw_target_size = Size2D::new(temporary_draw_target_size.width as AzFloat, + temporary_draw_target_size.height as AzFloat); // Blit the blur onto the tile. We undo the transforms here because we want to directly // stack the temporary draw target onto the tile. main_draw_target.set_transform(&Matrix2D::identity()); main_draw_target.draw_filter(&filter, - &Rect(Point2D(0.0, 0.0), temporary_draw_target_size), + &Rect::new(Point2D::new(0.0, 0.0), temporary_draw_target_size), &self.offset, DrawOptions::new(1.0, CompositionOp::Over, AntialiasMode::None)); main_draw_target.set_transform(&main_draw_target_transform); diff --git a/components/gfx/paint_task.rs b/components/gfx/paint_task.rs index a59be2a54b5..f640f56a541 100644 --- a/components/gfx/paint_task.rs +++ b/components/gfx/paint_task.rs @@ -13,7 +13,6 @@ use paint_context::PaintContext; use azure::azure_hl::{SurfaceFormat, Color, DrawTarget, BackendType}; use azure::AzFloat; use geom::Matrix4; -use geom::matrix::identity; use geom::point::Point2D; use geom::rect::Rect; use geom::size::Size2D; @@ -386,7 +385,7 @@ impl<C> PaintTask<C> where C: PaintListener + Send + 'static { // in case it dies in transit to the compositor task. let mut native_surface: NativeSurface = layers::platform::surface::NativeSurface::new(native_graphics_context!(self), - Size2D(width as i32, height as i32), + Size2D::new(width as i32, height as i32), width as i32 * 4); native_surface.mark_wont_leak(); @@ -463,10 +462,10 @@ impl<C> PaintTask<C> where C: PaintListener + Send + 'static { // the compositor is concerned. let overflow_relative_page_position = page_position + stacking_context.overflow.origin; let layer_position = - Rect(Point2D(overflow_relative_page_position.x.to_nearest_px() as f32, - overflow_relative_page_position.y.to_nearest_px() as f32), - Size2D(stacking_context.overflow.size.width.to_nearest_px() as f32, - stacking_context.overflow.size.height.to_nearest_px() as f32)); + Rect::new(Point2D::new(overflow_relative_page_position.x.to_nearest_px() as f32, + overflow_relative_page_position.y.to_nearest_px() as f32), + Size2D::new(stacking_context.overflow.size.width.to_nearest_px() as f32, + stacking_context.overflow.size.height.to_nearest_px() as f32)); properties.push(LayerProperties { id: paint_layer.id, rect: layer_position, @@ -587,7 +586,7 @@ impl WorkerThread { stacking_context: Arc<StackingContext>, scale: f32) -> DrawTarget { - let size = Size2D(tile.screen_rect.size.width as i32, tile.screen_rect.size.height as i32); + let size = Size2D::new(tile.screen_rect.size.width as i32, tile.screen_rect.size.height as i32); let draw_target = if !opts::get().gpu_painting { DrawTarget::new(BackendType::Skia, size, SurfaceFormat::B8G8R8A8) } else { @@ -618,11 +617,11 @@ impl WorkerThread { // Apply a translation to start at the boundaries of the stacking context, since the // layer's origin starts at its overflow rect's origin. let tile_bounds = tile.page_rect.translate( - &Point2D(stacking_context.overflow.origin.x.to_f32_px(), - stacking_context.overflow.origin.y.to_f32_px())); + &Point2D::new(stacking_context.overflow.origin.x.to_f32_px(), + stacking_context.overflow.origin.y.to_f32_px())); // Apply the translation to paint the tile we want. - let matrix: Matrix4 = identity(); + let matrix = Matrix4::identity(); let matrix = matrix.scale(scale as AzFloat, scale as AzFloat, 1.0); let matrix = matrix.translate(-tile_bounds.origin.x as AzFloat, -tile_bounds.origin.y as AzFloat, @@ -647,17 +646,17 @@ impl WorkerThread { // Overlay a transparent solid color to identify the thread that // painted this tile. let color = THREAD_TINT_COLORS[thread_id % THREAD_TINT_COLORS.len()]; - paint_context.draw_solid_color(&Rect(Point2D(Au(0), Au(0)), - Size2D(Au::from_px(size.width), - Au::from_px(size.height))), + paint_context.draw_solid_color(&Rect::new(Point2D::new(Au(0), Au(0)), + Size2D::new(Au::from_px(size.width), + Au::from_px(size.height))), color); } if opts::get().paint_flashing { // Overlay a random transparent color. let color = *rand::thread_rng().choose(&THREAD_TINT_COLORS[..]).unwrap(); - paint_context.draw_solid_color(&Rect(Point2D(Au(0), Au(0)), - Size2D(Au::from_px(size.width), - Au::from_px(size.height))), + paint_context.draw_solid_color(&Rect::new(Point2D::new(Au(0), Au(0)), + Size2D::new(Au::from_px(size.width), + Au::from_px(size.height))), color); } } diff --git a/components/gfx/text/shaping/harfbuzz.rs b/components/gfx/text/shaping/harfbuzz.rs index 9781fd76926..3ab0582cac5 100644 --- a/components/gfx/text/shaping/harfbuzz.rs +++ b/components/gfx/text/shaping/harfbuzz.rs @@ -130,7 +130,7 @@ impl ShapedGlyphData { *y_pos = *y_pos - y_advance; } - Some(Point2D(x_offset, *y_pos - y_offset)) + Some(Point2D::new(x_offset, *y_pos - y_offset)) }; ShapedGlyphEntry { diff --git a/components/layout/block.rs b/components/layout/block.rs index a064e031211..218dc9531ac 100644 --- a/components/layout/block.rs +++ b/components/layout/block.rs @@ -1047,7 +1047,7 @@ impl BlockFlow { self.base.floats.add_float(&info); // FIXME (mbrubeck) Get the correct container size for self.base.floats; - let container_size = Size2D(self.base.block_container_inline_size, Au(0)); + let container_size = Size2D::new(self.base.block_container_inline_size, Au(0)); // Move in from the margin edge, as per CSS 2.1 § 9.5, floats may not overlap anything on // their margin edges. @@ -1669,7 +1669,7 @@ impl Flow for BlockFlow { fn compute_absolute_position(&mut self, layout_context: &LayoutContext) { // FIXME (mbrubeck): Get the real container size, taking the container writing mode into // account. Must handle vertical writing modes. - let container_size = Size2D(self.base.block_container_inline_size, Au(0)); + let container_size = Size2D::new(self.base.block_container_inline_size, Au(0)); if self.is_root() { self.base.clip = ClippingRegion::max(); @@ -1776,7 +1776,7 @@ impl Flow for BlockFlow { // // FIXME(pcwalton): Is this vertical-writing-direction-safe? let margin = self.fragment.margin.to_physical(self.base.writing_mode); - origin_for_children = Point2D(-margin.left, Au(0)) + relative_offset; + origin_for_children = Point2D::new(-margin.left, Au(0)) + relative_offset; clip_in_child_coordinate_system = self.base.clip.translate(&-self.base.stacking_relative_position); } else { @@ -1789,7 +1789,7 @@ impl Flow for BlockFlow { let visible_rect = match layout_context.shared.visible_rects.get(&self.layer_id(0)) { Some(visible_rect) => *visible_rect, - None => Rect(Point2D::zero(), layout_context.shared.screen_size), + None => Rect::new(Point2D::zero(), layout_context.shared.screen_size), }; let screen_size = layout_context.shared.screen_size; diff --git a/components/layout/display_list_builder.rs b/components/layout/display_list_builder.rs index 5491e9d0bc6..d749dc3f969 100644 --- a/components/layout/display_list_builder.rs +++ b/components/layout/display_list_builder.rs @@ -22,7 +22,6 @@ use model::{self, MaybeAuto, ToGfxMatrix, ToAu}; use table_cell::CollapsedBordersForCell; use geom::{Point2D, Rect, Size2D, SideOffsets2D}; -use geom::matrix::identity; use geom::Matrix4; use gfx_traits::color; use gfx::display_list::{BLUR_INFLATION_FACTOR, BaseDisplayItem, BorderDisplayItem}; @@ -392,18 +391,18 @@ impl FragmentDisplayListBuilding for Fragment { // wide. let image_aspect_ratio = (image.width as f64) / (image.height as f64); let bounds_aspect_ratio = bounds.size.width.to_f64_px() / bounds.size.height.to_f64_px(); - let intrinsic_size = Size2D(Au::from_px(image.width as i32), - Au::from_px(image.height as i32)); + let intrinsic_size = Size2D::new(Au::from_px(image.width as i32), + Au::from_px(image.height as i32)); match (style.get_background().background_size.clone(), image_aspect_ratio < bounds_aspect_ratio) { (background_size::T::Contain, false) | (background_size::T::Cover, true) => { - Size2D(bounds.size.width, - Au::from_f64_px(bounds.size.width.to_f64_px() / image_aspect_ratio)) + Size2D::new(bounds.size.width, + Au::from_f64_px(bounds.size.width.to_f64_px() / image_aspect_ratio)) } (background_size::T::Contain, true) | (background_size::T::Cover, false) => { - Size2D(Au::from_f64_px(bounds.size.height.to_f64_px() * image_aspect_ratio), - bounds.size.height) + Size2D::new(Au::from_f64_px(bounds.size.height.to_f64_px() * image_aspect_ratio), + bounds.size.height) } (background_size::T::Explicit(background_size::ExplicitSize { @@ -412,7 +411,7 @@ impl FragmentDisplayListBuilding for Fragment { }), _) => { let width = MaybeAuto::from_style(width, bounds.size.width) .specified_or_default(intrinsic_size.width); - Size2D(width, Au::from_f64_px(width.to_f64_px() / image_aspect_ratio)) + Size2D::new(width, Au::from_f64_px(width.to_f64_px() / image_aspect_ratio)) } (background_size::T::Explicit(background_size::ExplicitSize { @@ -421,14 +420,14 @@ impl FragmentDisplayListBuilding for Fragment { }), _) => { let height = MaybeAuto::from_style(height, bounds.size.height) .specified_or_default(intrinsic_size.height); - Size2D(Au::from_f64_px(height.to_f64_px() * image_aspect_ratio), height) + Size2D::new(Au::from_f64_px(height.to_f64_px() * image_aspect_ratio), height) } (background_size::T::Explicit(background_size::ExplicitSize { width, height }), _) => { - Size2D(MaybeAuto::from_style(width, bounds.size.width) + Size2D::new(MaybeAuto::from_style(width, bounds.size.width) .specified_or_default(intrinsic_size.width), MaybeAuto::from_style(height, bounds.size.height) .specified_or_default(intrinsic_size.height)) @@ -542,7 +541,7 @@ impl FragmentDisplayListBuilding for Fragment { Cursor::DefaultCursor), clip), image: image.clone(), - stretch_size: Size2D(image_size.width, image_size.height), + stretch_size: Size2D::new(image_size.width, image_size.height), image_rendering: style.get_effects().image_rendering.clone(), }), level); } @@ -561,10 +560,10 @@ impl FragmentDisplayListBuilding for Fragment { // between the starting point and the ending point. let delta = match gradient.angle_or_corner { AngleOrCorner::Angle(angle) => { - Point2D(Au::from_f32_px(angle.radians().sin() * - absolute_bounds.size.width.to_f32_px() / 2.0), - Au::from_f32_px(-angle.radians().cos() * - absolute_bounds.size.height.to_f32_px() / 2.0)) + Point2D::new(Au::from_f32_px(angle.radians().sin() * + absolute_bounds.size.width.to_f32_px() / 2.0), + Au::from_f32_px(-angle.radians().cos() * + absolute_bounds.size.height.to_f32_px() / 2.0)) } AngleOrCorner::Corner(horizontal, vertical) => { let x_factor = match horizontal { @@ -575,8 +574,8 @@ impl FragmentDisplayListBuilding for Fragment { VerticalDirection::Top => -1, VerticalDirection::Bottom => 1, }; - Point2D(absolute_bounds.size.width * x_factor / 2, - absolute_bounds.size.height * y_factor / 2) + Point2D::new(absolute_bounds.size.width * x_factor / 2, + absolute_bounds.size.height * y_factor / 2) } }; @@ -643,8 +642,8 @@ impl FragmentDisplayListBuilding for Fragment { }) } - let center = Point2D(absolute_bounds.origin.x + absolute_bounds.size.width / 2, - absolute_bounds.origin.y + absolute_bounds.size.height / 2); + let center = Point2D::new(absolute_bounds.origin.x + absolute_bounds.size.width / 2, + absolute_bounds.origin.y + absolute_bounds.size.height / 2); let gradient_display_item = DisplayItem::GradientClass(box GradientDisplayItem { base: BaseDisplayItem::new(*absolute_bounds, @@ -669,8 +668,8 @@ impl FragmentDisplayListBuilding for Fragment { clip: &ClippingRegion) { // NB: According to CSS-BACKGROUNDS, box shadows render in *reverse* order (front to back). for box_shadow in style.get_effects().box_shadow.iter().rev() { - let bounds = shadow_bounds(&absolute_bounds.translate(&Point2D(box_shadow.offset_x, - box_shadow.offset_y)), + let bounds = shadow_bounds(&absolute_bounds.translate(&Point2D::new(box_shadow.offset_x, + box_shadow.offset_y)), box_shadow.blur_radius, box_shadow.spread_radius); list.push(DisplayItem::BoxShadowClass(box BoxShadowDisplayItem { @@ -681,7 +680,7 @@ impl FragmentDisplayListBuilding for Fragment { (*clip).clone()), box_bounds: *absolute_bounds, color: style.resolve_color(box_shadow.color).to_gfx_color(), - offset: Point2D(box_shadow.offset_x, box_shadow.offset_y), + offset: Point2D::new(box_shadow.offset_x, box_shadow.offset_y), blur_radius: box_shadow.blur_radius, spread_radius: box_shadow.spread_radius, clip_mode: if box_shadow.inset { @@ -867,12 +866,12 @@ impl FragmentDisplayListBuilding for Fragment { }; // FIXME(pcwalton, #2795): Get the real container size. - let clip_origin = Point2D(stacking_relative_border_box.origin.x + style_clip_rect.left, - stacking_relative_border_box.origin.y + style_clip_rect.top); + let clip_origin = Point2D::new(stacking_relative_border_box.origin.x + style_clip_rect.left, + stacking_relative_border_box.origin.y + style_clip_rect.top); let right = style_clip_rect.right.unwrap_or(stacking_relative_border_box.size.width); let bottom = style_clip_rect.bottom.unwrap_or(stacking_relative_border_box.size.height); - let clip_size = Size2D(right - clip_origin.x, bottom - clip_origin.y); - (*parent_clip).clone().intersect_rect(&Rect(clip_origin, clip_size)) + let clip_size = Size2D::new(right - clip_origin.x, bottom - clip_origin.y); + (*parent_clip).clone().intersect_rect(&Rect::new(clip_origin, clip_size)) } fn build_display_list(&mut self, @@ -1030,7 +1029,7 @@ impl FragmentDisplayListBuilding for Fragment { // to back). let text_color = self.style().get_color().color; for text_shadow in self.style.get_effects().text_shadow.0.iter().rev() { - let offset = &Point2D(text_shadow.offset_x, text_shadow.offset_y); + let offset = &Point2D::new(text_shadow.offset_x, text_shadow.offset_y); let color = self.style().resolve_color(text_shadow.color); self.build_display_list_for_text_fragment(display_list, &**text_fragment, @@ -1047,7 +1046,7 @@ impl FragmentDisplayListBuilding for Fragment { text_color, &stacking_relative_content_box, None, - &Point2D(Au(0), Au(0)), + &Point2D::new(Au(0), Au(0)), clip); if opts::get().show_debug_fragment_borders { @@ -1142,15 +1141,15 @@ impl FragmentDisplayListBuilding for Fragment { .relative_containing_block_mode, CoordinateSystem::Parent); - let mut transform = identity(); + let mut transform = Matrix4::identity(); if let Some(ref operations) = self.style().get_effects().transform { let transform_origin = self.style().get_effects().transform_origin; let transform_origin = - Point2D(model::specified(transform_origin.horizontal, - border_box.size.width).to_f32_px(), - model::specified(transform_origin.vertical, - border_box.size.height).to_f32_px()); + Point2D::new(model::specified(transform_origin.horizontal, + border_box.size.width).to_f32_px(), + model::specified(transform_origin.vertical, + border_box.size.height).to_f32_px()); let pre_transform = Matrix4::create_translation(transform_origin.x, transform_origin.y, @@ -1193,7 +1192,7 @@ impl FragmentDisplayListBuilding for Fragment { // FIXME(pcwalton): Is this vertical-writing-direction-safe? let margin = self.margin.to_physical(base_flow.writing_mode); - let overflow = base_flow.overflow.translate(&-Point2D(margin.left, Au(0))); + let overflow = base_flow.overflow.translate(&-Point2D::new(margin.left, Au(0))); // Create the filter pipeline. let effects = self.style().get_effects(); @@ -1241,10 +1240,10 @@ impl FragmentDisplayListBuilding for Fragment { layout_context: &LayoutContext) { let border_padding = (self.border_padding).to_physical(self.style.writing_mode); let content_size = self.content_box().size.to_physical(self.style.writing_mode); - let iframe_rect = Rect(Point2D((offset.x + border_padding.left).to_f32_px(), - (offset.y + border_padding.top).to_f32_px()), - Size2D(content_size.width.to_f32_px(), - content_size.height.to_f32_px())); + let iframe_rect = Rect::new(Point2D::new((offset.x + border_padding.left).to_f32_px(), + (offset.y + border_padding.top).to_f32_px()), + Size2D::new(content_size.width.to_f32_px(), + content_size.height.to_f32_px())); debug!("finalizing position and size of iframe for {:?},{:?}", iframe_fragment.pipeline_id, @@ -1726,8 +1725,8 @@ impl BaseFlowDisplayListBuilding for BaseFlow { let thread_id = self.thread_id; let stacking_context_relative_bounds = - Rect(self.stacking_relative_position, - self.position.size.to_physical(self.writing_mode)); + Rect::new(self.stacking_relative_position, + self.position.size.to_physical(self.writing_mode)); let mut color = THREAD_TINT_COLORS[thread_id as usize % THREAD_TINT_COLORS.len()]; color.a = 1.0; diff --git a/components/layout/flow.rs b/components/layout/flow.rs index 11d1c017db6..eae78fef05c 100644 --- a/components/layout/flow.rs +++ b/components/layout/flow.rs @@ -1072,7 +1072,7 @@ impl BaseFlow { let position_with_overflow = self.position .to_physical(self.writing_mode, container_size) .union(&self.overflow); - let bounds = Rect(self.stacking_relative_position, position_with_overflow.size); + let bounds = Rect::new(self.stacking_relative_position, position_with_overflow.size); let all_items = match self.display_list_building_result { DisplayListBuildingResult::None => Vec::new(), diff --git a/components/layout/fragment.rs b/components/layout/fragment.rs index 2815eb88db6..dddf6fa2572 100644 --- a/components/layout/fragment.rs +++ b/components/layout/fragment.rs @@ -1957,7 +1957,7 @@ impl Fragment { relative_containing_block_size.to_physical(relative_containing_block_mode); let border_box = self.border_box.to_physical(self.style.writing_mode, container_size); if coordinate_system == CoordinateSystem::Own && self.establishes_stacking_context() { - return Rect(ZERO_POINT, border_box.size) + return Rect::new(ZERO_POINT, border_box.size) } // FIXME(pcwalton): This can double-count relative position sometimes for inlines (e.g. @@ -1974,10 +1974,10 @@ impl Fragment { pub fn stacking_relative_content_box(&self, stacking_relative_border_box: &Rect<Au>) -> Rect<Au> { let border_padding = self.border_padding.to_physical(self.style.writing_mode); - Rect(Point2D(stacking_relative_border_box.origin.x + border_padding.left, - stacking_relative_border_box.origin.y + border_padding.top), - Size2D(stacking_relative_border_box.size.width - border_padding.horizontal(), - stacking_relative_border_box.size.height - border_padding.vertical())) + Rect::new(Point2D::new(stacking_relative_border_box.origin.x + border_padding.left, + stacking_relative_border_box.origin.y + border_padding.top), + Size2D::new(stacking_relative_border_box.size.width - border_padding.horizontal(), + stacking_relative_border_box.size.height - border_padding.vertical())) } /// Returns true if this fragment establishes a new stacking context and false otherwise. @@ -2033,7 +2033,7 @@ impl Fragment { // Box shadows cause us to draw outside our border box. for box_shadow in self.style().get_effects().box_shadow.iter() { - let offset = Point2D(box_shadow.offset_x, box_shadow.offset_y); + let offset = Point2D::new(box_shadow.offset_x, box_shadow.offset_y); let inflation = box_shadow.spread_radius + box_shadow.blur_radius * BLUR_INFLATION_FACTOR; overflow = overflow.union(&border_box.translate(&offset).inflate(inflation, inflation)) diff --git a/components/layout/inline.rs b/components/layout/inline.rs index c55a035f346..c5a896bc3c5 100644 --- a/components/layout/inline.rs +++ b/components/layout/inline.rs @@ -1467,7 +1467,7 @@ impl Flow for InlineFlow { fn compute_absolute_position(&mut self, _: &LayoutContext) { // First, gather up the positions of all the containing blocks (if any). let mut containing_block_positions = Vec::new(); - let container_size = Size2D(self.base.block_container_inline_size, Au(0)); + let container_size = Size2D::new(self.base.block_container_inline_size, Au(0)); for (fragment_index, fragment) in self.fragments.fragments.iter().enumerate() { if let SpecificFragmentInfo::InlineAbsolute(_) = fragment.specific { let containing_block_range = diff --git a/components/layout/layout_task.rs b/components/layout/layout_task.rs index f769f7ee3d7..19588819c95 100644 --- a/components/layout/layout_task.rs +++ b/components/layout/layout_task.rs @@ -28,7 +28,7 @@ use canvas_traits::CanvasMsg; use encoding::EncodingRef; use encoding::all::UTF_8; use fnv::FnvHasher; -use geom::matrix; +use geom::Matrix4; use geom::point::Point2D; use geom::rect::Rect; use geom::scale_factor::ScaleFactor; @@ -295,7 +295,7 @@ impl LayoutTask { time_profiler_chan: time::ProfilerChan, mem_profiler_chan: mem::ProfilerChan) -> LayoutTask { - let screen_size = Size2D(Au(0), Au(0)); + let screen_size = Size2D::new(Au(0), Au(0)); let device = Device::new( MediaType::Screen, opts::get().initial_window_size.as_f32() * ScaleFactor::new(1.0)); @@ -867,13 +867,13 @@ impl LayoutTask { let paint_layer = Arc::new(PaintLayer::new(layout_root.layer_id(0), root_background_color, ScrollPolicy::Scrollable)); - let origin = Rect(Point2D(Au(0), Au(0)), root_size); + let origin = Rect::new(Point2D::new(Au(0), Au(0)), root_size); let stacking_context = Arc::new(StackingContext::new(display_list, &origin, &origin, 0, - &matrix::identity(), + &Matrix4::identity(), filter::T::new(Vec::new()), mix_blend_mode::T::normal, Some(paint_layer))); @@ -916,8 +916,8 @@ impl LayoutTask { let initial_viewport = data.window_size.initial_viewport; let old_screen_size = rw_data.screen_size; - let current_screen_size = Size2D(Au::from_f32_px(initial_viewport.width.get()), - Au::from_f32_px(initial_viewport.height.get())); + let current_screen_size = Size2D::new(Au::from_f32_px(initial_viewport.width.get()), + Au::from_f32_px(initial_viewport.height.get())); rw_data.screen_size = current_screen_size; // Handle conditions where the entire flow tree is invalid. @@ -931,8 +931,8 @@ impl LayoutTask { debug!("Viewport constraints: {:?}", constraints); // other rules are evaluated against the actual viewport - rw_data.screen_size = Size2D(Au::from_f32_px(constraints.size.width.get()), - Au::from_f32_px(constraints.size.height.get())); + rw_data.screen_size = Size2D::new(Au::from_f32_px(constraints.size.width.get()), + Au::from_f32_px(constraints.size.height.get())); let device = Device::new(MediaType::Screen, constraints.size); rw_data.stylist.set_device(device); @@ -1035,8 +1035,8 @@ impl LayoutTask { let mut must_regenerate_display_lists = false; let mut old_visible_rects = HashMap::with_hash_state(Default::default()); let inflation_amount = - Size2D(rw_data.screen_size.width * DISPLAY_PORT_THRESHOLD_SIZE_FACTOR, - rw_data.screen_size.height * DISPLAY_PORT_THRESHOLD_SIZE_FACTOR); + Size2D::new(rw_data.screen_size.width * DISPLAY_PORT_THRESHOLD_SIZE_FACTOR, + rw_data.screen_size.height * DISPLAY_PORT_THRESHOLD_SIZE_FACTOR); for &(ref layer_id, ref new_visible_rect) in new_visible_rects.iter() { match rw_data.visible_rects.get(layer_id) { None => { @@ -1251,7 +1251,7 @@ impl LayoutRPC for LayoutRPCImpl { /// Requests the node containing the point of interest. fn hit_test(&self, _: TrustedNodeAddress, point: Point2D<f32>) -> Result<HitTestResponse, ()> { - let point = Point2D(Au::from_f32_px(point.x), Au::from_f32_px(point.y)); + let point = Point2D::new(Au::from_f32_px(point.x), Au::from_f32_px(point.y)); let resp = { let &LayoutRPCImpl(ref rw_data) = self; let rw_data = rw_data.lock().unwrap(); @@ -1278,7 +1278,7 @@ impl LayoutRPC for LayoutRPCImpl { fn mouse_over(&self, _: TrustedNodeAddress, point: Point2D<f32>) -> Result<MouseOverResponse, ()> { let mut mouse_over_list: Vec<DisplayItemMetadata> = vec!(); - let point = Point2D(Au::from_f32_px(point.x), Au::from_f32_px(point.y)); + let point = Point2D::new(Au::from_f32_px(point.x), Au::from_f32_px(point.y)); { let &LayoutRPCImpl(ref rw_data) = self; let rw_data = rw_data.lock().unwrap(); diff --git a/components/layout/table_cell.rs b/components/layout/table_cell.rs index d44de741e60..3f8b32254f8 100644 --- a/components/layout/table_cell.rs +++ b/components/layout/table_cell.rs @@ -324,14 +324,14 @@ impl CollapsedBordersForCell { // FIXME(pcwalton): Get the real container size. let mut logical_bounds = - LogicalRect::from_physical(writing_mode, *border_bounds, Size2D(Au(0), Au(0))); + LogicalRect::from_physical(writing_mode, *border_bounds, Size2D::new(Au(0), Au(0))); logical_bounds.start.i = logical_bounds.start.i - inline_start_offset; logical_bounds.start.b = logical_bounds.start.b - block_start_offset; logical_bounds.size.inline = logical_bounds.size.inline + inline_start_offset + inline_end_offset; logical_bounds.size.block = logical_bounds.size.block + block_start_offset + block_end_offset; - *border_bounds = logical_bounds.to_physical(writing_mode, Size2D(Au(0), Au(0))) + *border_bounds = logical_bounds.to_physical(writing_mode, Size2D::new(Au(0), Au(0))) } pub fn adjust_border_colors_and_styles_for_painting( diff --git a/components/script/dom/canvasrenderingcontext2d.rs b/components/script/dom/canvasrenderingcontext2d.rs index 596da8467c3..9ac3a97c55b 100644 --- a/components/script/dom/canvasrenderingcontext2d.rs +++ b/components/script/dom/canvasrenderingcontext2d.rs @@ -155,13 +155,13 @@ impl CanvasRenderingContext2D { image_size: Size2D<f64>, sx: f64, sy: f64, sw: f64, sh: f64, dx: f64, dy: f64, dw: f64, dh: f64) -> (Rect<f64>, Rect<f64>) { - let image_rect = Rect(Point2D(0f64, 0f64), - Size2D(image_size.width as f64, image_size.height as f64)); + let image_rect = Rect::new(Point2D::new(0f64, 0f64), + Size2D::new(image_size.width as f64, image_size.height as f64)); // The source rectangle is the rectangle whose corners are the four points (sx, sy), // (sx+sw, sy), (sx+sw, sy+sh), (sx, sy+sh). - let source_rect = Rect(Point2D(sx.min(sx+sw), sy.min(sy+sh)), - Size2D(sw.abs(), sh.abs())); + let source_rect = Rect::new(Point2D::new(sx.min(sx+sw), sy.min(sy+sh)), + Size2D::new(sw.abs(), sh.abs())); // When the source rectangle is outside the source image, // the source rectangle must be clipped to the source image @@ -178,13 +178,13 @@ impl CanvasRenderingContext2D { // The destination rectangle is the rectangle whose corners are the four points (dx, dy), // (dx+dw, dy), (dx+dw, dy+dh), (dx, dy+dh). - let dest_rect = Rect(Point2D(dx.min(dx+dest_rect_width_scaled), dy.min(dy+dest_rect_height_scaled)), - Size2D(dest_rect_width_scaled.abs(), dest_rect_height_scaled.abs())); + let dest_rect = Rect::new(Point2D::new(dx.min(dx+dest_rect_width_scaled), dy.min(dy+dest_rect_height_scaled)), + Size2D::new(dest_rect_width_scaled.abs(), dest_rect_height_scaled.abs())); - let source_rect = Rect(Point2D(source_rect_clipped.origin.x, - source_rect_clipped.origin.y), - Size2D(source_rect_clipped.size.width, - source_rect_clipped.size.height)); + let source_rect = Rect::new(Point2D::new(source_rect_clipped.origin.x, + source_rect_clipped.origin.y), + Size2D::new(source_rect_clipped.size.width, + source_rect_clipped.size.height)); return (source_rect, dest_rect) } @@ -220,7 +220,7 @@ impl CanvasRenderingContext2D { } let canvas_size = canvas.get_size(); - let image_size = Size2D(canvas_size.width as f64, canvas_size.height as f64); + let image_size = Size2D::new(canvas_size.width as f64, canvas_size.height as f64); // 2. Establish the source and destination rectangles let (source_rect, dest_rect) = self.adjust_source_dest_rects(image_size, sx, sy, sw, sh, dx, dy, dw, dh); @@ -287,7 +287,7 @@ impl CanvasRenderingContext2D { ImageResponse::PlaceholderLoaded(_) | ImageResponse::None => return None, }; - let image_size = Size2D(img.width as f64, img.height as f64); + let image_size = Size2D::new(img.width as f64, img.height as f64); let mut image_data = match img.pixels { PixelsByColorType::RGBA8(ref pixels) => pixels.to_vec(), PixelsByColorType::K8(_) => panic!("K8 color type not supported"), @@ -320,7 +320,7 @@ impl CanvasRenderingContext2D { return None; } - Some(Rect(Point2D(x as f32, y as f32), Size2D(w as f32, h as f32))) + Some(Rect::new(Point2D::new(x as f32, y as f32), Size2D::new(w as f32, h as f32))) } } @@ -703,7 +703,10 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> return; } - self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::MoveTo(Point2D(x as f32, y as f32)))).unwrap(); + let msg = CanvasMsg::Canvas2d( + Canvas2dMsg::MoveTo( + Point2D::new(x as f32, y as f32))); + self.renderer.send(msg).unwrap(); } // https://html.spec.whatwg.org/multipage/#dom-context-2d-lineto @@ -712,15 +715,19 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> return; } - self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::LineTo(Point2D(x as f32, y as f32)))).unwrap(); + let msg = CanvasMsg::Canvas2d( + Canvas2dMsg::LineTo( + Point2D::new(x as f32, y as f32))); + self.renderer.send(msg).unwrap(); } // https://html.spec.whatwg.org/multipage/#dom-context-2d-rect fn Rect(self, x: f64, y: f64, width: f64, height: f64) { if [x, y, width, height].iter().all(|val| val.is_finite()) { - let rect = Rect(Point2D(x as f32, y as f32), - Size2D(width as f32, height as f32)); - self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::Rect(rect))).unwrap(); + let rect = Rect::new(Point2D::new(x as f32, y as f32), + Size2D::new(width as f32, height as f32)); + let msg = CanvasMsg::Canvas2d(Canvas2dMsg::Rect(rect)); + self.renderer.send(msg).unwrap(); } } @@ -731,8 +738,11 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> return; } - self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::QuadraticCurveTo(Point2D(cpx as f32, cpy as f32), - Point2D(x as f32, y as f32)))).unwrap(); + let msg = CanvasMsg::Canvas2d( + Canvas2dMsg::QuadraticCurveTo( + Point2D::new(cpx as f32, cpy as f32), + Point2D::new(x as f32, y as f32))); + self.renderer.send(msg).unwrap(); } // https://html.spec.whatwg.org/multipage/#dom-context-2d-beziercurveto @@ -742,9 +752,12 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> return; } - self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::BezierCurveTo(Point2D(cp1x as f32, cp1y as f32), - Point2D(cp2x as f32, cp2y as f32), - Point2D(x as f32, y as f32)))).unwrap(); + let msg = CanvasMsg::Canvas2d( + Canvas2dMsg::BezierCurveTo( + Point2D::new(cp1x as f32, cp1y as f32), + Point2D::new(cp2x as f32, cp2y as f32), + Point2D::new(x as f32, y as f32))); + self.renderer.send(msg).unwrap(); } // https://html.spec.whatwg.org/multipage/#dom-context-2d-arc @@ -760,8 +773,12 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> return Err(IndexSize); } - self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::Arc(Point2D(x as f32, y as f32), r as f32, - start as f32, end as f32, ccw))).unwrap(); + let msg = CanvasMsg::Canvas2d( + Canvas2dMsg::Arc( + Point2D::new(x as f32, y as f32), r as f32, + start as f32, end as f32, ccw)); + + self.renderer.send(msg).unwrap(); Ok(()) } @@ -773,9 +790,13 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> if r < 0.0 { return Err(IndexSize); } - self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::ArcTo(Point2D(cp1x as f32, cp1y as f32), - Point2D(cp2x as f32, cp2y as f32), - r as f32))).unwrap(); + + let msg = CanvasMsg::Canvas2d( + Canvas2dMsg::ArcTo( + Point2D::new(cp1x as f32, cp1y as f32), + Point2D::new(cp2x as f32, cp2y as f32), + r as f32)); + self.renderer.send(msg).unwrap(); Ok(()) } @@ -907,9 +928,10 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> } let (sender, receiver) = channel::<Vec<u8>>(); - let dest_rect = Rect(Point2D(sx as f64, sy as f64), Size2D(sw as f64, sh as f64)); + let dest_rect = Rect::new(Point2D::new(sx as f64, sy as f64), + Size2D::new(sw as f64, sh as f64)); let canvas_size = self.canvas.root().r().get_size(); - let canvas_size = Size2D(canvas_size.width as f64, canvas_size.height as f64); + let canvas_size = Size2D::new(canvas_size.width as f64, canvas_size.height as f64); self.renderer.send(CanvasMsg::Canvas2d(Canvas2dMsg::GetImageData(dest_rect, canvas_size, sender))).unwrap(); let data = receiver.recv().unwrap(); Ok(ImageData::new(self.global.root().r(), sw.abs().to_u32().unwrap(), sh.abs().to_u32().unwrap(), Some(data))) @@ -929,8 +951,8 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> let data = imagedata.get_data_array(&self.global.root().r()); let image_data_size = imagedata.get_size(); - let image_data_size = Size2D(image_data_size.width as f64, image_data_size.height as f64); - let image_data_rect = Rect(Point2D(dx, dy), image_data_size); + let image_data_size = Size2D::new(image_data_size.width as f64, image_data_size.height as f64); + let image_data_rect = Rect::new(Point2D::new(dx, dy), image_data_size); let dirty_rect = None; let msg = CanvasMsg::Canvas2d(Canvas2dMsg::PutImageData(data, image_data_rect, dirty_rect)); self.renderer.send(msg).unwrap(); @@ -955,11 +977,11 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> // they will be TypeError by WebIDL spec before call this methods. let data = imagedata.get_data_array(&self.global.root().r()); - let image_data_rect = Rect(Point2D(dx, dy), - Size2D(imagedata.Width() as f64, - imagedata.Height() as f64)); - let dirty_rect = Some(Rect(Point2D(dirtyX, dirtyY), - Size2D(dirtyWidth, dirtyHeight))); + let image_data_rect = Rect::new(Point2D::new(dx, dy), + Size2D::new(imagedata.Width() as f64, + imagedata.Height() as f64)); + let dirty_rect = Some(Rect::new(Point2D::new(dirtyX, dirtyY), + Size2D::new(dirtyWidth, dirtyHeight))); let msg = CanvasMsg::Canvas2d(Canvas2dMsg::PutImageData(data, image_data_rect, dirty_rect)); self.renderer.send(msg).unwrap(); self.mark_as_dirty(); @@ -1019,7 +1041,7 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> ImageResponse::PlaceholderLoaded(_) | ImageResponse::None => return Err(InvalidState), }; - let image_size = Size2D(img.width as f64, img.height as f64); + let image_size = Size2D::new(img.width as f64, img.height as f64); let image_data = match img.pixels { PixelsByColorType::RGBA8(ref pixels) => pixels.to_vec(), PixelsByColorType::K8(_) => panic!("K8 color type not supported"), @@ -1030,7 +1052,7 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D> if let Some(rep) = RepetitionStyle::from_str(&repetition) { return Ok(CanvasPattern::new(self.global.root().r(), image_data, - Size2D(image_size.width as i32, image_size.height as i32), + Size2D::new(image_size.width as i32, image_size.height as i32), rep)); } return Err(Syntax); diff --git a/components/script/dom/htmlcanvaselement.rs b/components/script/dom/htmlcanvaselement.rs index 0b2456f3f54..f0367679e25 100644 --- a/components/script/dom/htmlcanvaselement.rs +++ b/components/script/dom/htmlcanvaselement.rs @@ -98,7 +98,7 @@ impl HTMLCanvasElement { } pub fn get_size(&self) -> Size2D<i32> { - Size2D(self.width.get() as i32, self.height.get() as i32) + Size2D::new(self.width.get() as i32, self.height.get() as i32) } } diff --git a/components/script/dom/imagedata.rs b/components/script/dom/imagedata.rs index 2748fa1d438..c935c51adcd 100644 --- a/components/script/dom/imagedata.rs +++ b/components/script/dom/imagedata.rs @@ -68,7 +68,7 @@ impl<'a> ImageDataHelpers for JSRef<'a, ImageData> { } fn get_size(&self) -> Size2D<i32> { - Size2D(self.Width() as i32, self.Height() as i32) + Size2D::new(self.Width() as i32, self.Height() as i32) } } diff --git a/components/script/dom/window.rs b/components/script/dom/window.rs index d8df4ad9c73..8be87d5be17 100644 --- a/components/script/dom/window.rs +++ b/components/script/dom/window.rs @@ -1020,10 +1020,10 @@ impl Window { } fn should_move_clip_rect(clip_rect: Rect<Au>, new_viewport: Rect<f32>) -> bool{ - let clip_rect = Rect(Point2D(clip_rect.origin.x.to_f32_px(), - clip_rect.origin.y.to_f32_px()), - Size2D(clip_rect.size.width.to_f32_px(), - clip_rect.size.height.to_f32_px())); + let clip_rect = Rect::new(Point2D::new(clip_rect.origin.x.to_f32_px(), + clip_rect.origin.y.to_f32_px()), + Size2D::new(clip_rect.size.width.to_f32_px(), + clip_rect.size.height.to_f32_px())); // We only need to move the clip rect if the viewport is getting near the edge of // our preexisting clip rect. We use half of the size of the viewport as a heuristic diff --git a/components/script/script_task.rs b/components/script/script_task.rs index 1d7b65ba1b4..323954521d6 100644 --- a/components/script/script_task.rs +++ b/components/script/script_task.rs @@ -1340,7 +1340,7 @@ impl ScriptTask { fn scroll_fragment_point(&self, pipeline_id: PipelineId, node: JSRef<Element>) { let node: JSRef<Node> = NodeCast::from_ref(node); let rect = node.get_bounding_content_box(); - let point = Point2D(rect.origin.x.to_f32_px(), rect.origin.y.to_f32_px()); + let point = Point2D::new(rect.origin.x.to_f32_px(), rect.origin.y.to_f32_px()); // FIXME(#2003, pcwalton): This is pretty bogus when multiple layers are involved. // Really what needs to happen is that this needs to go through layout to ask which // layer the element belongs to, and have it send the scroll message to the diff --git a/components/servo/Cargo.lock b/components/servo/Cargo.lock index 03579044ca3..97bb9efa9ca 100644 --- a/components/servo/Cargo.lock +++ b/components/servo/Cargo.lock @@ -385,7 +385,7 @@ dependencies = [ [[package]] name = "geom" version = "0.1.0" -source = "git+https://github.com/servo/rust-geom#1b49f8ce1c4e8ade720dd940d1964c657a96817f" +source = "git+https://github.com/servo/rust-geom#16b91afc0b9b532f2fb56879069bc381f2143df1" dependencies = [ "log 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)", "num 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)", @@ -624,7 +624,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "layers" version = "0.1.0" -source = "git+https://github.com/servo/rust-layers#ca37ca2949c46f91e37f28fa31ad6c1e8036f2d0" +source = "git+https://github.com/servo/rust-layers#e566d3fc6ec80fe3aaf8ce67785683c99c46a015" dependencies = [ "azure 0.1.0 (git+https://github.com/servo/rust-azure)", "cgl 0.0.1 (git+https://github.com/servo/cgl-rs)", @@ -856,7 +856,7 @@ dependencies = [ [[package]] name = "offscreen_gl_context" version = "0.0.1" -source = "git+https://github.com/ecoal95/rust-offscreen-rendering-context#0fd217b95d806bdcb6d381cf092ca8776de273c8" +source = "git+https://github.com/ecoal95/rust-offscreen-rendering-context#c402c86f8d4472785e04e59505feb28638101700" dependencies = [ "cgl 0.0.1 (git+https://github.com/servo/cgl-rs)", "core-foundation 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)", diff --git a/components/style/media_queries.rs b/components/style/media_queries.rs index 8472347721c..a63fea173ff 100644 --- a/components/style/media_queries.rs +++ b/components/style/media_queries.rs @@ -203,8 +203,8 @@ pub fn parse_media_query_list(input: &mut Parser) -> MediaQueryList { impl MediaQueryList { pub fn evaluate(&self, device: &Device) -> bool { - let viewport_size = Size2D(Au::from_f32_px(device.viewport_size.width.get()), - Au::from_f32_px(device.viewport_size.height.get())); + let viewport_size = Size2D::new(Au::from_f32_px(device.viewport_size.width.get()), + Au::from_f32_px(device.viewport_size.height.get())); // Check if any queries match (OR condition) self.media_queries.iter().any(|mq| { diff --git a/components/style/properties.mako.rs b/components/style/properties.mako.rs index 881d538a5ff..8d271ce846e 100644 --- a/components/style/properties.mako.rs +++ b/components/style/properties.mako.rs @@ -3896,7 +3896,7 @@ pub mod longhands { p2y = try!(input.expect_number()); Ok(()) })); - let (p1, p2) = (Point2D(p1x, p1y), Point2D(p2x, p2y)); + let (p1, p2) = (Point2D::new(p1x, p1y), Point2D::new(p2x, p2y)); Ok(TransitionTimingFunction::CubicBezier(p1, p2)) }, "steps" => { diff --git a/components/style/viewport.rs b/components/style/viewport.rs index 831c3769a56..176ad77e6fc 100644 --- a/components/style/viewport.rs +++ b/components/style/viewport.rs @@ -417,8 +417,8 @@ impl ViewportConstraints { // // Note: DEVICE-ADAPT § 5. states that relative length values are // resolved against initial values - let initial_viewport = Size2D(Au::from_f32_px(initial_viewport.width.get()), - Au::from_f32_px(initial_viewport.height.get())); + let initial_viewport = Size2D::new(Au::from_f32_px(initial_viewport.width.get()), + Au::from_f32_px(initial_viewport.height.get())); macro_rules! to_pixel_length { ($value:ident, $dimension:ident) => { @@ -496,7 +496,7 @@ impl ViewportConstraints { }); Some(ViewportConstraints { - size: TypedSize2D(width.to_f32_px(), height.to_f32_px()), + size: Size2D::typed(width.to_f32_px(), height.to_f32_px()), // TODO: compute a zoom factor for 'auto' as suggested by DEVICE-ADAPT § 10. initial_zoom: ScaleFactor::new(initial_zoom.unwrap_or(1.)), diff --git a/components/util/geometry.rs b/components/util/geometry.rs index ae149c5162e..25fb284fcb3 100644 --- a/components/util/geometry.rs +++ b/components/util/geometry.rs @@ -277,7 +277,7 @@ pub fn rect_contains_point<T:PartialOrd + Add<T, Output=T>>(rect: Rect<T>, point /// A helper function to convert a rect of `f32` pixels to a rect of app units. pub fn f32_rect_to_au_rect(rect: Rect<f32>) -> Rect<Au> { - Rect(Point2D(Au::from_f32_px(rect.origin.x), Au::from_f32_px(rect.origin.y)), - Size2D(Au::from_f32_px(rect.size.width), Au::from_f32_px(rect.size.height))) + Rect::new(Point2D::new(Au::from_f32_px(rect.origin.x), Au::from_f32_px(rect.origin.y)), + Size2D::new(Au::from_f32_px(rect.size.width), Au::from_f32_px(rect.size.height))) } diff --git a/components/util/opts.rs b/components/util/opts.rs index 19b5afa9a82..d5c91e64fb6 100644 --- a/components/util/opts.rs +++ b/components/util/opts.rs @@ -8,7 +8,7 @@ use geometry::ScreenPx; use geom::scale_factor::ScaleFactor; -use geom::size::TypedSize2D; +use geom::size::{Size2D, TypedSize2D}; use layers::geometry::DevicePixel; use getopts; use num_cpus; @@ -230,7 +230,7 @@ pub fn default_opts() -> Opts { trace_layout: false, devtools_port: None, webdriver_port: None, - initial_window_size: TypedSize2D(800, 600), + initial_window_size: Size2D::typed(800, 600), user_agent: None, dump_flow_tree: false, dump_display_list: false, @@ -375,10 +375,10 @@ pub fn from_cmdline_args(args: &[String]) -> bool { let initial_window_size = match opt_match.opt_str("resolution") { Some(res_string) => { let res: Vec<u32> = res_string.split('x').map(|r| r.parse().unwrap()).collect(); - TypedSize2D(res[0], res[1]) + Size2D::typed(res[0], res[1]) } None => { - TypedSize2D(800, 600) + Size2D::typed(800, 600) } }; diff --git a/ports/cef/Cargo.lock b/ports/cef/Cargo.lock index eddeb8bc644..f523c48e27b 100644 --- a/ports/cef/Cargo.lock +++ b/ports/cef/Cargo.lock @@ -384,7 +384,7 @@ dependencies = [ [[package]] name = "geom" version = "0.1.0" -source = "git+https://github.com/servo/rust-geom#1b49f8ce1c4e8ade720dd940d1964c657a96817f" +source = "git+https://github.com/servo/rust-geom#16b91afc0b9b532f2fb56879069bc381f2143df1" dependencies = [ "log 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)", "num 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)", @@ -616,7 +616,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "layers" version = "0.1.0" -source = "git+https://github.com/servo/rust-layers#ca37ca2949c46f91e37f28fa31ad6c1e8036f2d0" +source = "git+https://github.com/servo/rust-layers#e566d3fc6ec80fe3aaf8ce67785683c99c46a015" dependencies = [ "azure 0.1.0 (git+https://github.com/servo/rust-azure)", "cgl 0.0.1 (git+https://github.com/servo/cgl-rs)", @@ -836,7 +836,7 @@ dependencies = [ [[package]] name = "offscreen_gl_context" version = "0.0.1" -source = "git+https://github.com/ecoal95/rust-offscreen-rendering-context#0fd217b95d806bdcb6d381cf092ca8776de273c8" +source = "git+https://github.com/ecoal95/rust-offscreen-rendering-context#c402c86f8d4472785e04e59505feb28638101700" dependencies = [ "cgl 0.0.1 (git+https://github.com/servo/cgl-rs)", "core-foundation 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)", diff --git a/ports/cef/browser_host.rs b/ports/cef/browser_host.rs index 7c0e7f9f1ff..dd026ae01bb 100644 --- a/ports/cef/browser_host.rs +++ b/ports/cef/browser_host.rs @@ -11,8 +11,8 @@ use browser::{self, ServoCefBrowserExtensions}; use wrappers::CefWrap; use compositing::windowing::{WindowEvent, MouseWindowEvent}; -use geom::point::TypedPoint2D; -use geom::size::TypedSize2D; +use geom::point::Point2D; +use geom::size::Size2D; use libc::{c_double, c_int}; use msg::constellation_msg::{self, KeyModifiers, KeyState}; use script_traits::MouseButton; @@ -385,7 +385,7 @@ full_cef_class_impl! { .get_render_handler() .get_view_rect(this.downcast().browser.borrow().clone().unwrap(), &mut rect); } - let size = TypedSize2D(rect.width as u32, rect.height as u32); + let size = Size2D::typed(rect.width as u32, rect.height as u32); this.downcast().send_window_event(WindowEvent::Resize(size)); }} @@ -443,7 +443,7 @@ full_cef_class_impl! { cef_mouse_button_type_t::MBT_MIDDLE => MouseButton::Middle, cef_mouse_button_type_t::MBT_RIGHT => MouseButton::Right, }; - let point = TypedPoint2D((*event).x as f32, (*event).y as f32); + let point = Point2D::typed((*event).x as f32, (*event).y as f32); if mouse_up != 0 { this.downcast().send_window_event(WindowEvent::MouseWindowEventClass( MouseWindowEvent::Click(button_type, point))) @@ -457,7 +457,7 @@ full_cef_class_impl! { _mouse_exited: c_int [c_int],) -> () {{ let event: &cef_mouse_event = event; - let point = TypedPoint2D((*event).x as f32, (*event).y as f32); + let point = Point2D::typed((*event).x as f32, (*event).y as f32); this.downcast().send_window_event(WindowEvent::MouseWindowMoveEventClass(point)) }} @@ -469,8 +469,8 @@ full_cef_class_impl! { let event: &cef_mouse_event = event; let delta_x: c_int = delta_x; let delta_y: c_int = delta_y; - let delta = TypedPoint2D(delta_x as f32, delta_y as f32); - let origin = TypedPoint2D((*event).x as i32, (*event).y as i32); + let delta = Point2D::typed(delta_x as f32, delta_y as f32); + let origin = Point2D::typed((*event).x as i32, (*event).y as i32); this.downcast().send_window_event(WindowEvent::Scroll(delta, origin)) }} diff --git a/ports/cef/window.rs b/ports/cef/window.rs index 94c073abcc3..b50d94fa145 100644 --- a/ports/cef/window.rs +++ b/ports/cef/window.rs @@ -18,7 +18,7 @@ use wrappers::CefWrap; use compositing::compositor_task::{self, CompositorProxy, CompositorReceiver}; use compositing::windowing::{WindowEvent, WindowMethods}; use geom::scale_factor::ScaleFactor; -use geom::size::TypedSize2D; +use geom::size::{Size2D, TypedSize2D}; use gleam::gl; use layers::geometry::DevicePixel; use layers::platform::surface::NativeGraphicsMetadata; @@ -86,7 +86,7 @@ impl Window { Rc::new(Window { cef_browser: RefCell::new(None), - size: TypedSize2D(width, height) + size: Size2D::typed(width, height) }) } @@ -199,7 +199,7 @@ impl WindowMethods for Window { } } - TypedSize2D(rect.width as u32, rect.height as u32) + Size2D::typed(rect.width as u32, rect.height as u32) } } } @@ -208,14 +208,14 @@ impl WindowMethods for Window { fn size(&self) -> TypedSize2D<ScreenPx,f32> { let browser = self.cef_browser.borrow(); match *browser { - None => TypedSize2D(400.0, 300.0), + None => Size2D::typed(400.0, 300.0), Some(ref browser) => { let mut rect = cef_rect_t::zero(); browser.get_host() .get_client() .get_render_handler() .get_view_rect((*browser).clone(), &mut rect); - TypedSize2D(rect.width as f32, rect.height as f32) + Size2D::typed(rect.width as f32, rect.height as f32) } } } diff --git a/ports/glutin/window.rs b/ports/glutin/window.rs index 04a4276f856..86c9835d15c 100644 --- a/ports/glutin/window.rs +++ b/ports/glutin/window.rs @@ -7,7 +7,7 @@ use compositing::compositor_task::{self, CompositorProxy, CompositorReceiver}; use compositing::windowing::{WindowEvent, WindowMethods}; use geom::scale_factor::ScaleFactor; -use geom::size::TypedSize2D; +use geom::size::{Size2D, TypedSize2D}; use gleam::gl; use glutin; use layers::geometry::DevicePixel; @@ -26,7 +26,7 @@ use NestedEventLoopListener; #[cfg(feature = "window")] use compositing::windowing::{MouseWindowEvent, WindowNavigateMsg}; #[cfg(feature = "window")] -use geom::point::{Point2D, TypedPoint2D}; +use geom::point::Point2D; #[cfg(feature = "window")] use glutin::{Api, ElementState, Event, GlRequest, MouseButton, VirtualKeyCode}; #[cfg(feature = "window")] @@ -90,9 +90,9 @@ impl Window { window: glutin_window, event_queue: RefCell::new(vec!()), mouse_down_button: Cell::new(None), - mouse_down_point: Cell::new(Point2D(0, 0)), + mouse_down_point: Cell::new(Point2D::new(0, 0)), - mouse_pos: Cell::new(Point2D(0, 0)), + mouse_pos: Cell::new(Point2D::new(0, 0)), key_modifiers: Cell::new(KeyModifiers::empty()), }; @@ -113,7 +113,8 @@ impl Window { match g_nested_event_loop_listener { None => {} Some(listener) => { - (*listener).handle_event_from_nested_event_loop(WindowEvent::Resize(TypedSize2D(width, height))); + (*listener).handle_event_from_nested_event_loop( + WindowEvent::Resize(Size2D::typed(width, height))); } } } @@ -169,7 +170,7 @@ impl Window { } } Event::Resized(width, height) => { - self.event_queue.borrow_mut().push(WindowEvent::Resize(TypedSize2D(width, height))); + self.event_queue.borrow_mut().push(WindowEvent::Resize(Size2D::typed(width, height))); } Event::MouseInput(element_state, mouse_button) => { if mouse_button == MouseButton::Left || @@ -179,9 +180,9 @@ impl Window { } } Event::MouseMoved((x, y)) => { - self.mouse_pos.set(Point2D(x, y)); + self.mouse_pos.set(Point2D::new(x, y)); self.event_queue.borrow_mut().push( - WindowEvent::MouseWindowMoveEventClass(TypedPoint2D(x as f32, y as f32))); + WindowEvent::MouseWindowMoveEventClass(Point2D::typed(x as f32, y as f32))); } Event::MouseWheel(delta) => { if self.ctrl_pressed() { @@ -220,8 +221,8 @@ impl Window { /// Helper function to send a scroll event. fn scroll_window(&self, dx: f32, dy: f32) { let mouse_pos = self.mouse_pos.get(); - let event = WindowEvent::Scroll(TypedPoint2D(dx as f32, dy as f32), - TypedPoint2D(mouse_pos.x as i32, mouse_pos.y as i32)); + let event = WindowEvent::Scroll(Point2D::typed(dx as f32, dy as f32), + Point2D::typed(mouse_pos.x as i32, mouse_pos.y as i32)); self.event_queue.borrow_mut().push(event); } @@ -233,21 +234,21 @@ impl Window { let max_pixel_dist = 10f64; let event = match action { ElementState::Pressed => { - self.mouse_down_point.set(Point2D(x, y)); + self.mouse_down_point.set(Point2D::new(x, y)); self.mouse_down_button.set(Some(button)); - MouseWindowEvent::MouseDown(MouseButton::Left, TypedPoint2D(x as f32, y as f32)) + MouseWindowEvent::MouseDown(MouseButton::Left, Point2D::typed(x as f32, y as f32)) } ElementState::Released => { - let mouse_up_event = MouseWindowEvent::MouseUp(MouseButton::Left, TypedPoint2D(x as f32, y as f32)); + let mouse_up_event = MouseWindowEvent::MouseUp(MouseButton::Left, Point2D::typed(x as f32, y as f32)); match self.mouse_down_button.get() { None => mouse_up_event, Some(but) if button == but => { - let pixel_dist = self.mouse_down_point.get() - Point2D(x, y); + let pixel_dist = self.mouse_down_point.get() - Point2D::new(x, y); let pixel_dist = ((pixel_dist.x * pixel_dist.x + pixel_dist.y * pixel_dist.y) as f64).sqrt(); if pixel_dist < max_pixel_dist { self.event_queue.borrow_mut().push(WindowEvent::MouseWindowEventClass(mouse_up_event)); - MouseWindowEvent::Click(MouseButton::Left, TypedPoint2D(x as f32, y as f32)) + MouseWindowEvent::Click(MouseButton::Left, Point2D::typed(x as f32, y as f32)) } else { mouse_up_event } @@ -462,12 +463,12 @@ impl WindowMethods for Window { fn framebuffer_size(&self) -> TypedSize2D<DevicePixel, u32> { let scale_factor = self.window.hidpi_factor() as u32; let (width, height) = self.window.get_inner_size().unwrap(); - TypedSize2D(width * scale_factor, height * scale_factor) + Size2D::typed(width * scale_factor, height * scale_factor) } fn size(&self) -> TypedSize2D<ScreenPx, f32> { let (width, height) = self.window.get_inner_size().unwrap(); - TypedSize2D(width as f32, height as f32) + Size2D::typed(width as f32, height as f32) } fn present(&self) { @@ -672,11 +673,11 @@ impl Window { #[cfg(feature = "headless")] impl WindowMethods for Window { fn framebuffer_size(&self) -> TypedSize2D<DevicePixel, u32> { - TypedSize2D(self.width, self.height) + Size2D::typed(self.width, self.height) } fn size(&self) -> TypedSize2D<ScreenPx, f32> { - TypedSize2D(self.width as f32, self.height as f32) + Size2D::typed(self.width as f32, self.height as f32) } fn present(&self) { diff --git a/ports/gonk/Cargo.lock b/ports/gonk/Cargo.lock index 6e6f88fcaae..2f0f944e2d8 100644 --- a/ports/gonk/Cargo.lock +++ b/ports/gonk/Cargo.lock @@ -363,7 +363,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "geom" version = "0.1.0" -source = "git+https://github.com/servo/rust-geom#1b49f8ce1c4e8ade720dd940d1964c657a96817f" +source = "git+https://github.com/servo/rust-geom#16b91afc0b9b532f2fb56879069bc381f2143df1" dependencies = [ "log 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)", "num 0.1.25 (registry+https://github.com/rust-lang/crates.io-index)", @@ -550,7 +550,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "layers" version = "0.1.0" -source = "git+https://github.com/servo/rust-layers#ca37ca2949c46f91e37f28fa31ad6c1e8036f2d0" +source = "git+https://github.com/servo/rust-layers#e566d3fc6ec80fe3aaf8ce67785683c99c46a015" dependencies = [ "azure 0.1.0 (git+https://github.com/servo/rust-azure)", "cgl 0.0.1 (git+https://github.com/servo/cgl-rs)", @@ -753,7 +753,7 @@ dependencies = [ [[package]] name = "offscreen_gl_context" version = "0.0.1" -source = "git+https://github.com/ecoal95/rust-offscreen-rendering-context#0fd217b95d806bdcb6d381cf092ca8776de273c8" +source = "git+https://github.com/ecoal95/rust-offscreen-rendering-context#c402c86f8d4472785e04e59505feb28638101700" dependencies = [ "cgl 0.0.1 (git+https://github.com/servo/cgl-rs)", "core-foundation 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)", diff --git a/ports/gonk/src/input.rs b/ports/gonk/src/input.rs index e6be7d5b03f..42e9d6df41f 100644 --- a/ports/gonk/src/input.rs +++ b/ports/gonk/src/input.rs @@ -14,7 +14,7 @@ use std::thread; use std::sync::mpsc::Sender; use std::io::Read; -use geom::point::TypedPoint2D; +use geom::point::Point2D; use errno::errno; use libc::c_int; @@ -167,7 +167,7 @@ fn read_input_device(device_path: &Path, let delta_y = slotA.y - first_y; let dist = delta_x * delta_x + delta_y * delta_y; if dist < 16 { - let click_pt = TypedPoint2D(slotA.x as f32, slotA.y as f32); + let click_pt = Point2D::typed(slotA.x as f32, slotA.y as f32); println!("Dispatching click!"); sender.send( WindowEvent::MouseWindowEventClass( @@ -193,8 +193,8 @@ fn read_input_device(device_path: &Path, } else { println!("Touch move x: {}, y: {}", slotA.x, slotA.y); sender.send( - WindowEvent::Scroll(TypedPoint2D((slotA.x - last_x) as f32, (slotA.y - last_y) as f32), - TypedPoint2D(slotA.x, slotA.y))).ok().unwrap(); + WindowEvent::Scroll(Point2D::typed((slotA.x - last_x) as f32, (slotA.y - last_y) as f32), + Point2D::typed(slotA.x, slotA.y))).ok().unwrap(); last_x = slotA.x; last_y = slotA.y; if touch_count >= 2 { diff --git a/ports/gonk/src/window.rs b/ports/gonk/src/window.rs index f874545bd20..40221996afe 100644 --- a/ports/gonk/src/window.rs +++ b/ports/gonk/src/window.rs @@ -7,7 +7,7 @@ use compositing::compositor_task::{self, CompositorProxy, CompositorReceiver}; use compositing::windowing::{WindowEvent, WindowMethods}; use geom::scale_factor::ScaleFactor; -use geom::size::TypedSize2D; +use geom::size::{Size2D, TypedSize2D}; use layers::geometry::DevicePixel; use layers::platform::surface::NativeGraphicsMetadata; use libc::c_int; @@ -784,12 +784,12 @@ impl Drop for Window { impl WindowMethods for Window { /// Returns the size of the window in hardware pixels. fn framebuffer_size(&self) -> TypedSize2D<DevicePixel, u32> { - TypedSize2D(self.width as u32, self.height as u32) + Size2D::typed(self.width as u32, self.height as u32) } /// Returns the size of the window in density-independent "px" units. fn size(&self) -> TypedSize2D<ScreenPx, f32> { - TypedSize2D(self.width as f32, self.height as f32) + Size2D::typed(self.width as f32, self.height as f32) } /// Presents the window to the screen (perhaps by page flipping). diff --git a/tests/unit/style/media_queries.rs b/tests/unit/style/media_queries.rs index 65381f2b6aa..ff996a9e717 100644 --- a/tests/unit/style/media_queries.rs +++ b/tests/unit/style/media_queries.rs @@ -2,7 +2,7 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ -use geom::size::TypedSize2D; +use geom::size::Size2D; use style::stylesheets::{Stylesheet, CSSRuleIteratorExt}; use style::stylesheets::Origin; use style::media_queries::*; @@ -349,7 +349,7 @@ fn test_mq_malformed_expressions() { fn test_matching_simple() { let device = Device { media_type: MediaType::Screen, - viewport_size: TypedSize2D(200.0, 100.0), + viewport_size: Size2D::typed(200.0, 100.0), }; media_query_test(&device, "@media not all { a { color: red; } }", 0); @@ -368,7 +368,7 @@ fn test_matching_simple() { fn test_matching_width() { let device = Device { media_type: MediaType::Screen, - viewport_size: TypedSize2D(200.0, 100.0), + viewport_size: Size2D::typed(200.0, 100.0), }; media_query_test(&device, "@media { a { color: red; } }", 1); @@ -412,7 +412,7 @@ fn test_matching_width() { fn test_matching_invalid() { let device = Device { media_type: MediaType::Screen, - viewport_size: TypedSize2D(200.0, 100.0), + viewport_size: Size2D::typed(200.0, 100.0), }; media_query_test(&device, "@media fridge { a { color: red; } }", 0); diff --git a/tests/unit/style/viewport.rs b/tests/unit/style/viewport.rs index b2fd82069d5..970a91fc5c5 100644 --- a/tests/unit/style/viewport.rs +++ b/tests/unit/style/viewport.rs @@ -3,7 +3,7 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ use cssparser::Parser; -use geom::size::TypedSize2D; +use geom::size::Size2D; use geom::scale_factor::ScaleFactor; use style::media_queries::{Device, MediaType}; use style::parser::ParserContext; @@ -51,7 +51,7 @@ macro_rules! assert_decl_len { #[test] fn empty_viewport_rule() { - let device = Device::new(MediaType::Screen, TypedSize2D(800., 600.)); + let device = Device::new(MediaType::Screen, Size2D::typed(800., 600.)); test_viewport_rule("@viewport {}", &device, |declarations, css| { println!("{}", css); @@ -74,7 +74,7 @@ macro_rules! assert_decl_eq { #[test] fn simple_viewport_rules() { - let device = Device::new(MediaType::Screen, TypedSize2D(800., 600.)); + let device = Device::new(MediaType::Screen, Size2D::typed(800., 600.)); test_viewport_rule("@viewport { width: auto; height: auto;\ zoom: auto; min-zoom: 0; max-zoom: 200%;\ @@ -107,7 +107,7 @@ fn simple_viewport_rules() { #[test] fn cascading_within_viewport_rule() { - let device = Device::new(MediaType::Screen, TypedSize2D(800., 600.)); + let device = Device::new(MediaType::Screen, Size2D::typed(800., 600.)); // normal order of appearance test_viewport_rule("@viewport { min-width: 200px; min-width: auto; }", @@ -172,7 +172,7 @@ fn cascading_within_viewport_rule() { #[test] fn multiple_stylesheets_cascading() { - let device = Device::new(MediaType::Screen, TypedSize2D(800., 600.)); + let device = Device::new(MediaType::Screen, Size2D::typed(800., 600.)); let stylesheets = vec![ stylesheet!("@viewport { min-width: 100px; min-height: 100px; zoom: 1; }", UserAgent), @@ -217,11 +217,11 @@ fn constrain_viewport() { } } - let initial_viewport = TypedSize2D(800., 600.); + let initial_viewport = Size2D::typed(800., 600.); assert_eq!(ViewportConstraints::maybe_new(initial_viewport, from_css!("")), None); - let initial_viewport = TypedSize2D(800., 600.); + let initial_viewport = Size2D::typed(800., 600.); assert_eq!(ViewportConstraints::maybe_new(initial_viewport, from_css!("width: 320px auto")), Some(ViewportConstraints { size: initial_viewport, @@ -234,10 +234,10 @@ fn constrain_viewport() { orientation: Orientation::Auto })); - let initial_viewport = TypedSize2D(200., 150.); + let initial_viewport = Size2D::typed(200., 150.); assert_eq!(ViewportConstraints::maybe_new(initial_viewport, from_css!("width: 320px auto")), Some(ViewportConstraints { - size: TypedSize2D(320., 240.), + size: Size2D::typed(320., 240.), initial_zoom: ScaleFactor::new(1.), min_zoom: None, @@ -247,7 +247,7 @@ fn constrain_viewport() { orientation: Orientation::Auto })); - let initial_viewport = TypedSize2D(800., 600.); + let initial_viewport = Size2D::typed(800., 600.); assert_eq!(ViewportConstraints::maybe_new(initial_viewport, from_css!("width: 320px auto")), Some(ViewportConstraints { size: initial_viewport, @@ -260,7 +260,7 @@ fn constrain_viewport() { orientation: Orientation::Auto })); - let initial_viewport = TypedSize2D(800., 600.); + let initial_viewport = Size2D::typed(800., 600.); assert_eq!(ViewportConstraints::maybe_new(initial_viewport, from_css!("width: 800px; height: 600px;\ zoom: 1;\ user-zoom: zoom;\ diff --git a/tests/unit/util/logical_geometry.rs b/tests/unit/util/logical_geometry.rs index d336d441734..c0df54c3b3f 100644 --- a/tests/unit/util/logical_geometry.rs +++ b/tests/unit/util/logical_geometry.rs @@ -24,7 +24,7 @@ fn modes() -> [WritingMode; 10] { #[test] fn test_size_round_trip() { - let physical = Size2D(1u32, 2u32); + let physical = Size2D::new(1u32, 2u32); for &mode in modes().iter() { let logical = LogicalSize::from_physical(mode, physical); assert!(logical.to_physical(mode) == physical); @@ -35,8 +35,8 @@ fn test_size_round_trip() { #[test] fn test_point_round_trip() { - let physical = Point2D(1u32, 2u32); - let container = Size2D(100, 200); + let physical = Point2D::new(1u32, 2u32); + let container = Size2D::new(100, 200); for &mode in modes().iter() { let logical = LogicalPoint::from_physical(mode, physical, container); assert!(logical.to_physical(mode, container) == physical); @@ -60,8 +60,8 @@ fn test_margin_round_trip() { #[test] fn test_rect_round_trip() { - let physical = Rect(Point2D(1u32, 2u32), Size2D(3u32, 4u32)); - let container = Size2D(100, 200); + let physical = Rect::new(Point2D::new(1u32, 2u32), Size2D::new(3u32, 4u32)); + let container = Size2D::new(100, 200); for &mode in modes().iter() { let logical = LogicalRect::from_physical(mode, physical, container); assert!(logical.to_physical(mode, container) == physical); |