Clean up and annotations

1 files changed, 17 insertions, 36 deletions

diff --git a/src/components/main/compositing/mod.rs b/src/components/main/compositing/mod.rs
index efb089e92e6..543d2e564cd 100644
--- a/src/components/main/compositing/mod.rs
+++ b/src/components/main/compositing/mod.rs
@@ -28,7 +28,6 @@ use extra::timer;
 use geom::matrix::identity;
 use geom::point::Point2D;
 use geom::size::Size2D;
-use geom::rect::Rect; //eschweic
 use layers::layers::{ARGB32Format, ContainerLayer, ContainerLayerKind, Format};
 use layers::layers::{ImageData, WithDataFn};
 use layers::layers::{TextureLayerKind, TextureLayer, TextureManager};
@@ -119,8 +118,7 @@ pub enum Msg {
     /// Requests the compositors GL context.
     GetGLContext(Chan<AzGLContext>),
 
-    //eschweic
-    // FIXME: Attach layer ids and epochs to these messages
+    // TODO: Attach layer ids and epochs to these messages
     /// Alerts the compositor that there is a new layer to be rendered.
     NewLayer(Size2D<uint>, uint),
     /// Alerts the compositor that the current layer has changed size.
@@ -237,7 +235,9 @@ impl CompositorTask {
         let ask_for_tiles: @fn() = || {
             match *quadtree {
                 Some(ref quad) => {
-                    let mut tile_size = quad.get_tile_size(); // temporary solution
+                    // FIXME: find a better way to get the tile size
+                    // currently tiles that need to be updated can be missed
+                    let mut tile_size = quad.get_tile_size();
                     let mut tile_request = ~[]; //FIXME: try not to allocate if possible
                     
                     let mut y = world_offset.y as uint;
@@ -253,15 +253,15 @@ impl CompositorTask {
                                 }
                                 None => {} // fall through
                             }
-                            let (tile_pos, new_tile_size) = quad.get_tile_rect(x, y, *world_zoom);
-                            tile_size = new_tile_size;
-                            x = tile_pos.x;
-                            y = tile_pos.y;
+                            let (tile_screen_pos, tile_page_pos) = quad.get_tile_rect(x, y, *world_zoom);
+                            tile_size = tile_screen_pos.size.width;
+                            x = tile_screen_pos.origin.x;
+                            y = tile_screen_pos.origin.y;
                             
                             // TODO: clamp tiles to page bounds
                             // TODO: add null buffer/checkerboard tile to stop a flood of requests
-                            println(fmt!("requesting tile: (%?, %?): %?", x, y, tile_size));
-                            tile_request.push(Rect(Point2D(x, y), Size2D(tile_size, tile_size)));
+                            debug!("requesting tile: (%?, %?): %?", x, y, tile_size);
+                            tile_request.push((tile_screen_pos, tile_page_pos));
                             
                             x += tile_size;
                         }
@@ -325,32 +325,14 @@ impl CompositorTask {
                     }
                     WindowMouseDownEvent(button, layer_mouse_point) => {
                         event = MouseDownEvent(button, world_mouse_point(layer_mouse_point));
-                        
-                        //eschweic
-                        match *quadtree {
-                            Some(ref quad) => {
-
-/*                                let wmp = world_mouse_point(layer_mouse_point);
-                                println(fmt!("mouse: (%?, %?):", wmp.x as uint, wmp.y as uint)); 
-                                let buffer = quad.get_tile(wmp.x as uint, wmp.y as uint, *world_zoom);
-                                match *buffer {
-                                    None => println("None"),
-                                    Some(ref buffer) => println(fmt!("Some: (%?, %?), %?, %?", buffer.screen_pos.origin.x, buffer.screen_pos.origin.y, buffer.screen_pos.size.width, buffer.resolution)),
-                               
-                                } */
-
-                                println(quad.get_html());
-                            }
-                            None => {}
-                        }
+
                     }
                     WindowMouseUpEvent(button, layer_mouse_point) => {
                         
-                        //FIXME: this should not be here eschweic
+                        // FIXME: this should happen on a scroll/zoom event instead,
+                        // but is here temporarily to prevent request floods to the renderer
                         ask_for_tiles();
 
-                        
-
                         event = MouseUpEvent(button, world_mouse_point(layer_mouse_point));
                     }
                 }
@@ -385,7 +367,6 @@ impl CompositorTask {
 
                     GetGLContext(chan) => chan.send(current_gl_context()),
                     
-                    //eschweic
                     NewLayer(new_size, tile_size) => {
                         *page_size = Size2D(new_size.width as f32, new_size.height as f32);
                         *quadtree = Some(Quadtree::new(0, 0, new_size.width, new_size.height, tile_size));
@@ -430,8 +411,8 @@ impl CompositorTask {
                         }
                         
                         for quad.get_all_tiles().each |buffer| {
-                            let width = buffer.rect.size.width as uint;
-                            let height = buffer.rect.size.height as uint;
+                            let width = buffer.screen_pos.size.width as uint;
+                            let height = buffer.screen_pos.size.height as uint;
 
                             debug!("osmain: compositing buffer rect %?", &buffer.rect);
                             
@@ -457,11 +438,11 @@ impl CompositorTask {
                                 Some(_) => fail!(~"found unexpected layer kind"),
                             };
 
-                            let origin = buffer.screen_pos.origin;
+                            let origin = buffer.rect.origin;
                             let origin = Point2D(origin.x as f32, origin.y as f32);
 
                             // Set the layer's transform.
-                            let transform = identity().translate(origin.x * *world_zoom / buffer.resolution, origin.y * *world_zoom / buffer.resolution, 0.0);
+                            let transform = identity().translate(origin.x * *world_zoom, origin.y * *world_zoom, 0.0);
                             let transform = transform.scale(width as f32 * *world_zoom / buffer.resolution, height as f32 * *world_zoom / buffer.resolution, 1.0);
                             texture_layer.common.set_transform(transform);