HTML List works #1

src/components/gfx/text/shaping/harfbuzz.rs

@@ -64,17 +64,14 @@ pub struct ShapedGlyphEntry {
 impl ShapedGlyphData {
     pub fn new(buffer: *hb_buffer_t) -> ShapedGlyphData {
         unsafe {
-            let glyph_count = 0;
+            let glyph_count = 0 as c_uint;
             let glyph_infos = hb_buffer_get_glyph_infos(buffer, &glyph_count);
-            let glyph_count = glyph_count as uint;
             assert!(glyph_infos.is_not_null());
-            let pos_count = 0;
-            let pos_infos = hb_buffer_get_glyph_positions(buffer, &pos_count);
+            let pos_infos = hb_buffer_get_glyph_positions(buffer, &glyph_count);
             assert!(pos_infos.is_not_null());
-            assert!(glyph_count == pos_count as uint);
 
             ShapedGlyphData {
-                count: glyph_count,
+                count: glyph_count as uint,
                 glyph_infos: glyph_infos,
                 pos_infos: pos_infos,
             }
@@ -231,7 +228,11 @@ impl Shaper {
         // so, we must be careful to increment this when saving glyph entries.
         let mut char_idx = 0;
 
-        assert!(glyph_count <= char_max);
+        // FIXME(recrack) : glyph_count is depending on the font.
+        // Example : (I, II is roman upper character unicode)
+        // I = glyph_count(1u), char_max(1u)
+        // II = glyph_count(2u), char_max(1u)
+        //assert!(glyph_count <= char_max);
 
         debug!("Shaped text[char count={:u}], got back {:u} glyph info records.",
                char_max,

src/components/main/css/user-agent.css

@@ -51,22 +51,25 @@ thead, tbody,
     s, strike, del  { text-decoration: line-through }
     hr              { border: 1px inset }
 
-/* lists */
-dd                  { display: block; margin-left: 40px }
-p, dl, multicol     { display: block; margin: 1em 0 }
-ul                  { display: block; list-style-type: disc; 
-                      margin: 1em 0; padding-left: 40px }
-
-ol                  { display: block; list-style-type: decimal;
-                      margin: 1em 0; padding-left: 40px }
+p                   { display: block; margin: 1em 0 }
 
+/* 14.3.8 Lists : http://www.whatwg.org/specs/web-apps/current-work/multipage/rendering.html#lists */
+dd, dl, dt, ol, ul  { display: block; }
 li                  { display: list-item }
 
+dl, ol, ul          { margin-top: 1em; margin-bottom: 1em; }
+
 /* nested lists have no top/bottom margins */
 ul ul, ul ol, ul dl,
 ol ul, ol ol, ol dl,
 dl ul, dl ol, dl dl { margin-top: 0; margin-bottom: 0 }
 
+dd                  { margin-left: 40px; }  /* LTR-specific: use 'margin-right' for rtl elements */
+ol, ul              { padding-left: 40px; } /* LTR-specific: use 'padding-right' for rtl elements */
+
+ol                  { list-style-type: decimal; }
+ul                  { list-style-type: disc; }
+
 /* 2 deep unordered lists use a circle */
 ol ul,   ul ul      { list-style-type: circle; }
 
@@ -75,14 +78,14 @@ ol ol ul, ol ul ul,
 ul ol ul, ul ul ul  { list-style-type: square; }
 
 /* The type attribute on ol and ul elements */
-ul[type="disc"]     { list-style-type: disc; }
-ul[type="circle"]   { list-style-type: circle; }
-ul[type="square"]   { list-style-type: square; }
-ol[type="1"]        { list-style-type: decimal; }
-ol[type="a"]        { list-style-type: lower-alpha; }
-ol[type="A"]        { list-style-type: upper-alpha; }
-ol[type="i"]        { list-style-type: lower-roman; }
-ol[type="I"]        { list-style-type: upper-roman; }
+ol[type="1"], li[type="1"] { list-style-type: decimal; }
+ol[type="a"], li[type="a"] { list-style-type: lower-alpha; }
+ol[type="A"], li[type="A"] { list-style-type: upper-alpha; }
+ol[type="i"], li[type="i"] { list-style-type: lower-roman; }
+ol[type="I"], li[type="I"] { list-style-type: upper-roman; }
+ul[type="disc"], li[type="disc"] { list-style-type: disc; }
+ul[type="circle"], li[type="circle"] { list-style-type: circle; }
+ul[type="square"], li[type="square"] { list-style-type: square; }
 
 u, ins              { text-decoration: underline }
 br:before           { content: "\A"; white-space: pre-line }

src/components/main/layout/block.rs

@@ -120,6 +120,10 @@ impl BlockFlow {
         self.float.is_some()
     }
 
+    pub fn is_list(&self) -> bool {
+        self.base.listdata.is_some()
+    }
+
     pub fn teardown(&mut self) {
         for box_ in self.box_.iter() {
             box_.teardown();
@@ -492,27 +496,41 @@ impl BlockFlow {
         box_.position.set(position);
     }
 
+    /// wrapper of build_display_list. For switching to html list.
+    pub fn build_display_list_wrapper<E:ExtraDisplayListData>(
+                                      &self,
+                                      builder: &DisplayListBuilder,
+                                      dirty: &Rect<Au>,
+                                      offset: Point2D<Au>,
+                                      flow: &Flow,
+                                      list: &RefCell<DisplayList<E>>) {
+        if self.is_list() {
+            for box_ in self.box_.iter() {
+                box_.add_marker_to_display_list(builder, dirty, flow, list)
+            }
+        }
+
+        // add box that starts block context
+        for box_ in self.box_.iter() {
+            box_.build_display_list(builder, dirty, offset, flow, list)
+        }
+    }
+
     pub fn build_display_list_block<E:ExtraDisplayListData>(
                                     &mut self,
                                     builder: &DisplayListBuilder,
                                     dirty: &Rect<Au>,
                                     list: &RefCell<DisplayList<E>>)
                                     -> bool {
-        if self.is_float() {
-            return self.build_display_list_float(builder, dirty, list);
-        }
-
         let abs_rect = Rect(self.base.abs_position, self.base.position.size);
         if !abs_rect.intersects(dirty) {
             return true;
         }
 
         debug!("build_display_list_block: adding display element");
 
-        // add box that starts block context
-        for box_ in self.box_.iter() {
-            box_.build_display_list(builder, dirty, self.base.abs_position, (&*self) as &Flow, list)
-        }
+        self.build_display_list_wrapper(builder, dirty, self.base.abs_position, (&*self) as &Flow, list);
+
         // TODO: handle any out-of-flow elements
         let this_position = self.base.abs_position;
 
@@ -536,11 +554,8 @@ impl BlockFlow {
         }
 
         let offset = self.base.abs_position + self.float.get_ref().rel_pos;
-        // add box that starts block context
-        for box_ in self.box_.iter() {
-            box_.build_display_list(builder, dirty, offset, (&*self) as &Flow, list)
-        }
-
+
+        self.build_display_list_wrapper(builder, dirty, offset, (&*self) as &Flow, list);
 
         // TODO: handle any out-of-flow elements
 

src/components/main/layout/box_.rs

@@ -14,6 +14,7 @@ use gfx::display_list::{SolidColorDisplayItem, SolidColorDisplayItemClass, TextD
 use gfx::display_list::{TextDisplayItemClass, TextDisplayItemFlags, ClipDisplayItem};
 use gfx::display_list::{ClipDisplayItemClass};
 use gfx::font::FontStyle;
+use gfx::font_context::FontContext;
 
 use gfx::text::text_run::TextRun;
 use servo_msg::constellation_msg::{FrameRectMsg, PipelineId, SubpageId};
@@ -1210,6 +1211,62 @@ impl Box {
         self.paint_borders_if_applicable(list, &absolute_box_bounds);
     }
 
+    /// Adds list marker into displaylist. This refers listdata in FlowData.
+    /// FIXME(aydin.kim) : Is it better that we add ListBox and handle in build_display_list?
+    pub fn add_marker_to_display_list<E:ExtraDisplayListData>(
+                                      &self,
+                                      builder: &DisplayListBuilder,
+                                      dirty: &Rect<Au>,
+                                      flow: &Flow,
+                                      list: &RefCell<DisplayList<E>>) {
+        if self.style().Box.visibility != visibility::visible {
+            return;
+        }
+
+        let listdata = flow::base(flow).listdata.unwrap();
+        let convert = builder.numbers;
+        let text = convert.to_list_style_type(listdata.list_style_type, listdata.sequence);
+
+        let color = self.style().Color.color.to_gfx_color();
+        let font_style = self.font_style();
+        //FIXME(aydin.kim) : In the future, we do not have to create new font context. Need to get unicode chracter values from css style sheet directly. when we will complete that works, this code has to be modified.
+        let mut font_context = ~FontContext::new(builder.ctx.font_context_info.clone());
+        let fontgroup = font_context.get_resolved_font_for_style(&font_style);
+        let text = RefCell::new(text);
+        let run = ~fontgroup.borrow().with(|fg| fg.create_textrun(text.get(), text_decoration::none));
+        let text_range = Range::new(0, text.get().len());
+        let text_bounds = run.metrics_for_range(&text_range).bounding_box;
+        let em_size = text_bounds.size.height;
+        let line_height = self.calculate_line_height(em_size);
+        let text_offset = (line_height - em_size).scale_by(0.5);
+        let marker_offset = &Point2D(-run.min_width_for_range(&text_range), text_offset);
+
+        let marker_bound = Rect(flow::base(flow).abs_position, text_bounds.size).translate(marker_offset);
+        if !marker_bound.intersects(dirty) {
+            return;
+        }
+
+
+        // Create the text box.
+        list.with_mut(|list| {
+            let text_display_item = ~TextDisplayItem {
+                base: BaseDisplayItem {
+                    bounds: marker_bound,
+                    extra: ExtraDisplayListData::new(self),
+                },
+                text_run: Arc::new(run.clone()),
+                range: text_range,
+                text_color: color,
+                overline_color: color,
+                underline_color: color,
+                line_through_color: color,
+                flags: TextDisplayItemFlags::new(),
+            };
+
+            list.append_item(TextDisplayItemClass(text_display_item))
+        });
+
+    }
     /// Returns the *minimum width* and *preferred width* of this box as defined by CSS 2.1.
     pub fn minimum_and_preferred_widths(&self) -> (Au, Au) {
         let guessed_width = self.guess_width();

src/components/main/layout/construct.rs

@@ -27,20 +27,25 @@ use layout::box_::{UnscannedTextBox, UnscannedTextBoxInfo, InlineInfo, InlinePar
 use layout::context::LayoutContext;
 use layout::float_context::FloatType;
 use layout::flow::{BaseFlow, Flow, LeafSet, MutableOwnedFlowUtils};
+use layout::flow;
 use layout::inline::InlineFlow;
 use layout::text::TextRunScanner;
 use layout::util::{LayoutDataAccess, OpaqueNode};
-use layout::wrapper::{LayoutNode, PostorderNodeMutTraversal};
+use layout::wrapper::{LayoutNode, PostorderNodeMutTraversal, LayoutElement};
 
 use gfx::font_context::FontContext;
 use script::dom::element::{HTMLIframeElementTypeId, HTMLImageElementTypeId};
+use script::dom::element::{HTMLUListElementTypeId, HTMLOListElementTypeId, ElementTypeId};
 use script::dom::node::{CommentNodeTypeId, DoctypeNodeTypeId, DocumentFragmentNodeTypeId};
 use script::dom::node::{DocumentNodeTypeId, ElementNodeTypeId, TextNodeTypeId};
 use style::computed_values::{display, position, float};
+use style::TNode;
+use style::TElement;
 
 use std::cell::RefCell;
 use std::util;
 use std::num::Zero;
+use servo_util::namespace;
 
 /// The results of flow construction for a DOM node.
 pub enum ConstructionResult {
@@ -295,6 +300,57 @@ impl<'fc> FlowConstructor<'fc> {
         }
     }
 
+    fn recursive_order_check(&mut self, flow: &mut ~Flow, mut list_cnt: int, is_ordered: bool, is_reversed: bool) -> int {
+        for child_flow in flow::child_iter(*flow) {
+            list_cnt = self.recursive_order_check(child_flow, list_cnt, is_ordered, is_reversed);
+            match child_flow.class() {
+                flow::BlockFlowClass => {
+                    if child_flow.as_block().is_list() && !child_flow.as_block().base.listdata.get_mut_ref().sequenced() {
+                        child_flow.as_block().base.listdata.get_mut_ref().from_list_tag(list_cnt, is_ordered);
+                        if is_reversed { list_cnt -= 1; }
+                        else { list_cnt += 1; }
+                    }
+                },
+                _ => {},
+            }
+        }
+        list_cnt
+    }
+
+    fn parse_attr_for_list(&mut self, node: LayoutNode) -> (Option<ElementTypeId>, int, bool, bool) {
+        //FIXME(aydin.kim) : boost up the flow traverse. Sequence checking in time of parsing is needed?
+        let mut list_start_num: int = 1;
+        let mut is_ordered = false;
+        let mut is_reversed = false;
+        return match node.type_id() {
+            ElementNodeTypeId(typeid) if typeid == HTMLUListElementTypeId || typeid == HTMLOListElementTypeId=> {
+                match typeid {
+                    HTMLUListElementTypeId => {
+                        is_ordered = false;
+                    },
+                    HTMLOListElementTypeId => {
+                        is_ordered = true;
+
+                        match node.with_element(|e: &LayoutElement| {e.get_attr(&namespace::Null, "start")}) {
+                            Some(s) => {
+                                let conv_seq: Option<int> = from_str(s);
+                                if conv_seq.is_some() { list_start_num = conv_seq.unwrap(); }
+                                else { list_start_num = 1; }
+                            },
+                            None => {},
+                        };
+                        if node.with_element(|e: &LayoutElement| {e.get_attr(&namespace::Null, "reversed")}).is_some() {
+                            is_reversed = true;
+                        }
+                    },
+                    _ => {},
+                }
+                (Some(typeid), list_start_num, is_ordered, is_reversed)
+            },
+            _ =>(None, 1, false, false) //just a dummy value
+        }
+    } 
+
     /// Builds the children flows underneath a node with `display: block`. After this call,
     /// other `BlockFlow`s or `InlineFlow`s will be populated underneath this node, depending on
     /// whether {ib} splits needed to happen.
@@ -304,17 +360,37 @@ impl<'fc> FlowConstructor<'fc> {
         // Gather up boxes for the inline flows we might need to create.
         let mut opt_boxes_for_inline_flow = None;
         let mut first_box = true;
+
+        let (list_type, list_start_num, is_ordered, is_reversed) = self.parse_attr_for_list(node);
+        let mut list_cnt = list_start_num;
+
+        // Children..
         for kid in node.children() {
             match kid.swap_out_construction_result() {
                 NoConstructionResult => {}
-                FlowConstructionResult(kid_flow) => {
+                FlowConstructionResult(mut kid_flow) => {
                     // Strip ignorable whitespace from the start of this flow per CSS 2.1 §
                     // 9.2.1.1.
                     if first_box {
                         strip_ignorable_whitespace_from_start(&mut opt_boxes_for_inline_flow);
                         first_box = false
                     }
 
+                    //Processing html list tag for backward compatibility.
+                    if list_type.is_some() {
+                        if kid_flow.as_block().is_list() && !kid_flow.as_block().base.listdata.get_mut_ref().sequenced() {
+                            kid_flow.as_block().base.listdata.get_mut_ref().from_list_tag(list_cnt, is_ordered);
+                            if is_reversed { list_cnt -= 1; }
+                            else { list_cnt += 1; }
+                        }
+
+                        if (kid.type_id() != ElementNodeTypeId(HTMLUListElementTypeId))
+                        && (kid.type_id() != ElementNodeTypeId(HTMLOListElementTypeId)) {
+                            //FIXME(aydin.kim): Actually we don't need sequence and reverse check in the case of UL. 
+                            list_cnt = self.recursive_order_check(&mut kid_flow, list_cnt, is_ordered, is_reversed);
+                        }
+                    }
+
                     // Flush any inline boxes that we were gathering up. This allows us to handle
                     // {ib} splits.
                     debug!("flushing {} inline box(es) to flow A",
@@ -388,6 +464,18 @@ impl<'fc> FlowConstructor<'fc> {
                                                      node);
     }
 
+    ///Builds a flow for a node. In here, we can switch the flow type to make.
+    fn build_block_flow(&mut self, node: LayoutNode, float_value: float::T, is_fixed: bool) -> ~Flow {
+        let flow = match float_value {
+            float::none => self.build_flow_for_block(node, is_fixed),
+            _ => {
+                let float_type = FloatType::from_property(float_value);
+                self.build_flow_for_floated_block(node, float_type)
+            }
+        };
+        flow
+    }
+
     /// Builds a flow for a node with `display: block`. This yields a `BlockFlow` with possibly
     /// other `BlockFlow`s or `InlineFlow`s underneath it, depending on whether {ib} splits needed
     /// to happen.
@@ -651,15 +739,10 @@ impl<'a> PostorderNodeMutTraversal for FlowConstructor<'a> {
                 let flow = self.build_flow_for_block(node, true);
                 node.set_flow_construction_result(FlowConstructionResult(flow))
             }
-            (_, float::none, _) => {
-                let flow = self.build_flow_for_block(node, false);
-                node.set_flow_construction_result(FlowConstructionResult(flow))
-            }
 
             // Floated flows contribute float flow construction results.
             (_, float_value, _) => {
-                let float_type = FloatType::from_property(float_value);
-                let flow = self.build_flow_for_floated_block(node, float_type);
+                let flow = self.build_block_flow(node, float_value, false);
                 node.set_flow_construction_result(FlowConstructionResult(flow))
             }
         }