gfx: Place rects in the layer buffers, not just sizes

src/servo/gfx/compositor.rs

@@ -1,7 +1,7 @@
 use azure::azure_hl::{DrawTarget};
 use cairo::cairo_hl::ImageSurface;
 use dom::event::Event;
-use geom::size::Size2D;
+use geom::rect::Rect;
 
 struct LayerBuffer {
     // TODO: We should not be coupled to Cairo this tightly. Instead we should pull the buffer out
@@ -10,7 +10,8 @@ struct LayerBuffer {
 
     draw_target: DrawTarget,
 
-    size: Size2D<uint>,
+    // The rect in the containing RenderLayer that this represents.
+    rect: Rect<uint>,
 
     // NB: stride is in pixels, like OpenGL GL_UNPACK_ROW_LENGTH.
     stride: uint

src/servo/gfx/png_compositor.rs

@@ -5,29 +5,31 @@ Each time the renderer renders a frame the compositor will output a
 `~[u8]` containing the frame in PNG format.
 */
 
-use libc::{c_int, c_uint, c_void, c_uchar};
+use azure::azure_hl::DrawTarget;
 use azure_bg = azure::bindgen;
 use azure_bg::{AzCreateDrawTargetForCairoSurface, AzReleaseDrawTarget};
-use azure::azure_hl::DrawTarget;
 use cairo::cairo_hl::ImageSurface;
 use cairo::{CAIRO_FORMAT_ARGB32, cairo_surface_t, cairo_status_t, CAIRO_STATUS_SUCCESS};
 use cairo_bg = cairo::bindgen;
 use cairo_bg::{cairo_image_surface_create, cairo_surface_destroy};
 use cairo_bg::{cairo_surface_write_to_png_stream};
-use compositor::Compositor;
-use render_task::{RenderTask, RenderMsg};
-use task::spawn_listener;
-use comm::{Chan, Port};
 use cast::reinterpret_cast;
-use ptr::addr_of;
+use comm::{Chan, Port};
+use compositor::Compositor;
+use core::io::BytesWriter;
+use display_list::DisplayList;
 use dom::event::Event;
 use dvec::DVec;
-use display_list::DisplayList;
+use geom::point::Point2D;
-use std::cell::Cell;
+use geom::rect::Rect;
-use core::io::BytesWriter;
-use gfx::compositor::{LayerBuffer, LayerBufferSet};
 use geom::size::Size2D;
+use gfx::compositor::{LayerBuffer, LayerBufferSet};
 use gfx::render_layers::RenderLayer;
+use libc::{c_int, c_uint, c_void, c_uchar};
+use ptr::addr_of;
+use render_task::{RenderTask, RenderMsg};
+use std::cell::Cell;
+use task::spawn_listener;
 
 pub type PngCompositor = Chan<Msg>;
 
@@ -53,7 +55,7 @@ pub fn PngCompositor(output: Chan<~[u8]>) -> PngCompositor {
         let layer_buffer = LayerBuffer {
             cairo_surface: cairo_surface.clone(),
             draw_target: move draw_target,
-            size: Size2D(800u, 600u),
+            rect: Rect(Point2D(0u, 0u), Size2D(800u, 600u)),
             stride: 800
         };
         let layer_buffer_set = LayerBufferSet { buffers: ~[ move layer_buffer ] };

src/servo/gfx/render_context.rs

@@ -79,7 +79,8 @@ impl RenderContext  {
     fn clear(&self) {
         let pattern = ColorPattern(Color(1f as AzFloat, 1f as AzFloat, 1f as AzFloat, 1f as AzFloat));
         let rect = Rect(Point2D(0 as AzFloat, 0 as AzFloat),
-                        Size2D(self.canvas.size.width as AzFloat, self.canvas.size.height as AzFloat));
+                        Size2D(self.canvas.rect.size.width as AzFloat,
+                               self.canvas.rect.size.height as AzFloat));
         self.canvas.draw_target.fill_rect(&rect, &pattern);
     }
 }

src/servo/gfx/render_layers.rs

@@ -5,6 +5,8 @@ use azure::azure_hl::DrawTarget;
 use cairo::CAIRO_FORMAT_RGB24;
 use cairo::cairo_hl::ImageSurface;
 use core::libc::c_int;
+use geom::point::Point2D;
+use geom::rect::Rect;
 use geom::size::Size2D;
 
 pub struct RenderLayer {
@@ -21,7 +23,7 @@ pub fn render_layers(layer: &RenderLayer,
                      f: &fn(layer: &RenderLayer, buffer: &LayerBuffer) -> bool) -> LayerBufferSet {
     let mut buffers = match move buffer_set { LayerBufferSet { buffers: move b } => move b };
     let mut buffer = buffers.pop();
-    if buffer.size != layer.size {
+    if buffer.rect.size != layer.size {
         // Create a new buffer.
 
         // Round the width up the nearest 32 pixels for DMA on the Mac.
@@ -39,7 +41,7 @@ pub fn render_layers(layer: &RenderLayer,
         buffer = LayerBuffer {
             cairo_surface: move cairo_surface,
             draw_target: move draw_target,
-            size: copy layer.size,
+            rect: Rect(Point2D(0u, 0u), copy layer.size),
             stride: stride
         };
     }

src/servo/platform/osmain.rs

@@ -7,6 +7,8 @@ use core::util::replace;
 use dom::event::{Event, ResizeEvent};
 use dvec::DVec;
 use geom::matrix::{Matrix4, identity};
+use geom::point::Point2D;
+use geom::rect::Rect;
 use geom::size::Size2D;
 use gfx::compositor::{Compositor, LayerBuffer, LayerBufferSet};
 use layers::ImageLayer;
@@ -122,8 +124,8 @@ fn mainloop(mode: Mode, po: comm::Port<Msg>, dom_event_chan: pipes::SharedChan<E
                     lend_surface(surfaces, move sender);
 
                     let buffers = &mut surfaces.front.layer_buffer_set.buffers;
-                    let width = buffers[0].size.width as uint;
+                    let width = buffers[0].rect.size.width as uint;
-                    let height = buffers[0].size.height as uint;
+                    let height = buffers[0].rect.size.height as uint;
 
                     let image_data = @CairoSurfaceImageData {
                         cairo_surface: buffers[0].cairo_surface.clone(),
@@ -226,7 +228,7 @@ fn lend_surface(surfaces: &SurfaceSet, receiver: pipes::Chan<LayerBufferSet>) {
         let layer_buffer = LayerBuffer {
             cairo_surface: layer_buffer.cairo_surface.clone(),
             draw_target: draw_target_ref.clone(),
-            size: copy layer_buffer.size,
+            rect: copy layer_buffer.rect,
             stride: layer_buffer.stride
         };
         #debug("osmain: lending surface %?", layer_buffer);
@@ -271,7 +273,7 @@ fn Surface() -> Surface {
     let layer_buffer = LayerBuffer {
         cairo_surface: move cairo_surface,
         draw_target: move draw_target,
-        size: Size2D(800u, 600u),
+        rect: Rect(Point2D(0u, 0u), Size2D(800u, 600u)),
         stride: 800
     };
     let layer_buffer_set = LayerBufferSet { buffers: ~[ move layer_buffer ] };