Implement Document.createElementNS()

src/components/gfx/display_list.rs

@@ -127,6 +127,7 @@ pub enum DisplayItem<E> {
     TextDisplayItemClass(~TextDisplayItem<E>),
     ImageDisplayItemClass(~ImageDisplayItem<E>),
     BorderDisplayItemClass(~BorderDisplayItem<E>),
+    LineDisplayItemClass(~LineDisplayItem<E>),
     ClipDisplayItemClass(~ClipDisplayItem<E>)
 }
 
@@ -206,6 +207,17 @@ pub struct BorderDisplayItem<E> {
     style: SideOffsets2D<border_style::T>
 }
 
+/// Renders a line segment
+pub struct LineDisplayItem<E> {
+    base: BaseDisplayItem<E>,
+
+    /// The line segment color.
+    color: Color,
+
+    /// The line segemnt style.
+    style: border_style::T
+}
+
 pub struct ClipDisplayItem<E> {
     base: BaseDisplayItem<E>,
     child_list: ~[DisplayItem<E>],
@@ -303,6 +315,12 @@ impl<E> DisplayItem<E> {
                                            border.color,
                                            border.style)
             }
+
+            LineDisplayItemClass(ref line) => {
+                render_context.draw_line(&line.base.bounds,
+                                          line.color,
+                                          line.style)
+            }
         }
     }
 
@@ -314,6 +332,7 @@ impl<E> DisplayItem<E> {
                 TextDisplayItemClass(ref text) => transmute_region(&text.base),
                 ImageDisplayItemClass(ref image_item) => transmute_region(&image_item.base),
                 BorderDisplayItemClass(ref border) => transmute_region(&border.base),
+                LineDisplayItemClass(ref line) => transmute_region(&line.base),
                 ClipDisplayItemClass(ref clip) => transmute_region(&clip.base),
             }
         }
@@ -329,7 +348,8 @@ impl<E> DisplayItem<E> {
             SolidColorDisplayItemClass(..) |
             TextDisplayItemClass(..) |
             ImageDisplayItemClass(..) |
-            BorderDisplayItemClass(..) => EmptyDisplayItemIterator,
+            BorderDisplayItemClass(..) |
+            LineDisplayItemClass(..) => EmptyDisplayItemIterator,
         }
     }
 
@@ -350,6 +370,7 @@ impl<E> DisplayItem<E> {
             TextDisplayItemClass(_) => "Text",
             ImageDisplayItemClass(_) => "Image",
             BorderDisplayItemClass(_) => "Border",
+            LineDisplayItemClass(_) => "Line",
             ClipDisplayItemClass(_) => "Clip",
         };
         format!("{} @ {:?}", class, self.base().bounds)

src/components/gfx/render_context.rs

@@ -62,6 +62,15 @@ impl<'a> RenderContext<'a>  {
         self.draw_border_segment(Left, bounds, border, color, style);
     }
 
+    pub fn draw_line(&self,
+                     bounds: &Rect<Au>,
+                     color: Color,
+                     style: border_style::T) {
+        self.draw_target.make_current();
+
+        self.draw_line_segment(bounds, color, style);
+    }
+
     pub fn draw_push_clip(&self, bounds: &Rect<Au>) {
         let rect = bounds.to_azure_rect();
         let path_builder = self.draw_target.create_path_builder();
@@ -148,6 +157,25 @@ impl<'a> RenderContext<'a>  {
         }
     }
 
+    fn draw_line_segment(&self, bounds: &Rect<Au>, color: Color, style: border_style::T) {
+        let border = SideOffsets2D::new_all_same(bounds.size.width).to_float_px();
+
+        match style{
+            border_style::none | border_style::hidden => {}
+            border_style::dotted => {
+                //FIXME(sankha93): Dotted style should be implemented.
+            }
+            border_style::dashed => {
+                self.draw_dashed_border_segment(Right,bounds,border,color);
+            }
+            border_style::solid => {
+                self.draw_solid_border_segment(Right,bounds,border,color);
+            }
+            //FIXME(sankha93): Five more styles should be implemented.
+            //double, groove, ridge, inset, outset
+        }
+    }
+
     fn draw_dashed_border_segment(&self, direction: Direction, bounds: &Rect<Au>, border: SideOffsets2D<f32>, color: Color) {
         let rect = bounds.to_azure_rect();
         let draw_opts = DrawOptions(1 as AzFloat, 0 as uint16_t);

src/components/main/compositing/compositor.rs

@@ -39,12 +39,16 @@ use servo_util::{time, url};
 use std::comm::Port;
 use std::num::Orderable;
 use std::path::Path;
-use std::rc::Rc;
 
+//FIXME: switch to std::rc when we upgrade Rust
+use layers::temp_rc::Rc;
+//use std::rc::Rc;
+
+use std::rc;
 
 pub struct IOCompositor {
     /// The application window.
-    window: Rc<Window>,
+    window: rc::Rc<Window>,
 
     /// The port on which we receive messages.
     port: Port<Msg>,
@@ -53,7 +57,7 @@ pub struct IOCompositor {
     context: RenderContext,
 
     /// The root ContainerLayer.
-    root_layer: @mut ContainerLayer,
+    root_layer: Rc<ContainerLayer>,
 
     /// The canvas to paint a page.
     scene: Scene,
@@ -116,21 +120,21 @@ impl IOCompositor {
                port: Port<Msg>,
                constellation_chan: ConstellationChan,
                profiler_chan: ProfilerChan) -> IOCompositor {
-        let window: Rc<Window> = WindowMethods::new(app);
+        let window: rc::Rc<Window> = WindowMethods::new(app);
 
         // Create an initial layer tree.
         //
         // TODO: There should be no initial layer tree until the renderer creates one from the display
         // list. This is only here because we don't have that logic in the renderer yet.
-        let root_layer = @mut ContainerLayer();
+        let root_layer = Rc::new(ContainerLayer());
         let window_size = window.borrow().size();
 
         IOCompositor {
             window: window,
             port: port,
             opts: opts,
             context: rendergl::init_render_context(),
-            root_layer: root_layer,
+            root_layer: root_layer.clone(),
             scene: Scene(ContainerLayerKind(root_layer), window_size, identity()),
             window_size: Size2D(window_size.width as uint, window_size.height as uint),
             graphics_context: CompositorTask::create_graphics_context(),
@@ -317,16 +321,22 @@ impl IOCompositor {
         response_chan.send(());
 
         // This assumes there is at most one child, which should be the case.
-        match self.root_layer.first_child {
-            Some(old_layer) => self.root_layer.remove_child(old_layer),
-            None => {}
+        // NOTE: work around borrowchk
+        {
+            let tmp = self.root_layer.borrow().first_child.borrow();
+            match *tmp.get() {
+                Some(ref old_layer) => ContainerLayer::remove_child(self.root_layer.clone(),
+                                                                     old_layer.clone()),
+                None => {}
+            }
         }
 
         let layer = CompositorLayer::from_frame_tree(frame_tree,
                                                      self.opts.tile_size,
                                                      Some(10000000u),
                                                      self.opts.cpu_painting);
-        self.root_layer.add_child_start(ContainerLayerKind(layer.root_layer));
+        ContainerLayer::add_child_start(self.root_layer.clone(),
+                                        ContainerLayerKind(layer.root_layer.clone()));
 
         // If there's already a root layer, destroy it cleanly.
         match self.compositor_layer {
@@ -360,13 +370,17 @@ impl IOCompositor {
                                              Some(10000000u),
                                              self.opts.cpu_painting);
 
-        let current_child = self.root_layer.first_child;
-        // This assumes there is at most one child, which should be the case.
-        match current_child {
-            Some(old_layer) => self.root_layer.remove_child(old_layer),
-            None => {}
+        {
+            let current_child = self.root_layer.borrow().first_child.borrow();
+            // This assumes there is at most one child, which should be the case.
+            match *current_child.get() {
+                Some(ref old_layer) => ContainerLayer::remove_child(self.root_layer.clone(),
+                                                                     old_layer.clone()),
+                None => {}
+            }
         }
-        self.root_layer.add_child_start(ContainerLayerKind(new_layer.root_layer));
+        ContainerLayer::add_child_start(self.root_layer.clone(),
+                                        ContainerLayerKind(new_layer.root_layer.clone()));
         self.compositor_layer = Some(new_layer);
 
         self.ask_for_tiles();
@@ -617,7 +631,7 @@ impl IOCompositor {
         self.world_zoom = (self.world_zoom * magnification).max(&1.0);
         let world_zoom = self.world_zoom;
 
-        self.root_layer.common.set_transform(identity().scale(world_zoom, world_zoom, 1f32));
+        self.root_layer.borrow().common.with_mut(|common| common.set_transform(identity().scale(world_zoom, world_zoom, 1f32)));
 
         // Scroll as needed
         let page_delta = Point2D(window_size.width as f32 * (1.0 / world_zoom - 1.0 / old_world_zoom) * 0.5,