From 8ea5c64bd0f998e4d28857bd30d0419a4f3273b6 Mon Sep 17 00:00:00 2001 From: "Brian J. Burg" Date: Mon, 22 Oct 2012 11:42:38 -0700 Subject: [PATCH] Stop combining several UnscannedTextboxes into a single TextBox, since it loses node mapping information. --- src/servo/layout/inline.rs | 43 +++++++++++++++----------------------- src/servo/util/range.rs | 18 ++++++++++++++++ 2 files changed, 35 insertions(+), 26 deletions(-) diff --git a/src/servo/layout/inline.rs b/src/servo/layout/inline.rs index 4b6d62b8e8d..2e282f35bad 100644 --- a/src/servo/layout/inline.rs +++ b/src/servo/layout/inline.rs @@ -67,7 +67,7 @@ impl TextRunScanner { for uint::range(0, in_boxes.len()) |box_i| { debug!("TextRunScanner: considering box: %?", in_boxes[box_i].debug_str()); - if box_i > 0 && !can_coalesce_boxes(in_boxes, box_i-1, box_i) { + if box_i > 0 && !can_coalesce_text_nodes(in_boxes, box_i-1, box_i) { self.flush_clump_to_list(ctx, in_boxes, &out_boxes); } self.clump.extend_by(1); @@ -84,7 +84,7 @@ impl TextRunScanner { } // helper functions - pure fn can_coalesce_boxes(boxes: &[@RenderBox], left_i: uint, right_i: uint) -> bool { + pure fn can_coalesce_text_nodes(boxes: &[@RenderBox], left_i: uint, right_i: uint) -> bool { assert left_i >= 0 && left_i < boxes.len(); assert right_i > 0 && right_i < boxes.len(); assert left_i != right_i; @@ -122,7 +122,7 @@ impl TextRunScanner { }; match (is_singleton, is_text_clump) { - (false, false) => fail ~"WAT: can't coalesce non-text boxes in flush_clump_to_list()!", + (false, false) => fail ~"WAT: can't coalesce non-text nodes in flush_clump_to_list()!", (true, false) => { debug!("TextRunScanner: pushing single non-text box in range: %?", self.clump); out_boxes.push(in_boxes[self.clump.begin()]); @@ -153,39 +153,30 @@ impl TextRunScanner { transform_text(in_boxes[idx].raw_text(), compression) }); - // then, fix NodeRange mappings to account for elided boxes. - do self.flow.inline().elems.borrow |ranges: &[NodeRange]| { - for ranges.each |node_range: &NodeRange| { - let range = &node_range.range; - let relation = range.relation_to_range(&self.clump); - debug!("TextRunScanner: possibly repairing element range %?", node_range.range); - debug!("TextRunScanner: relation of range and clump(%?): %?", - self.clump, relation); - match relation { - EntirelyBefore => {}, - EntirelyAfter => { range.shift_by(-(self.clump.length() as int)); }, - Coincides | ContainedBy => { range.reset(self.clump.begin(), 1); }, - Contains => { range.extend_by(-(self.clump.length() as int)); }, - OverlapsBegin(overlap) => { range.extend_by(1 - (overlap as int)); }, - OverlapsEnd(overlap) => - { range.reset(self.clump.begin(), range.length() - overlap + 1); } - } - debug!("TextRunScanner: new element range: ---- %?", node_range.range); - } - } + // next, concatenate all of the transformed strings together, saving the new text indices // TODO(Issue #118): use a rope, simply give ownership of nonzero strs to rope let mut run_str : ~str = ~""; + let new_ranges : DVec = DVec(); for uint::range(0, transformed_strs.len()) |i| { + // XXX: if transformed_strs[i].len() == 0 { loop } + new_ranges.push(Range(run_str.len(), transformed_strs[i].len())); str::push_str(&mut run_str, transformed_strs[i]); } + + // TODO: adjust containing ranges to account for any elided boxes (see XXX above, below) + // create the run, then make new boxes with the run and adjusted text indices + // TODO(Issue #116): use actual font for corresponding DOM node to create text run. let run = @TextRun(ctx.font_cache.get_test_font(), move run_str); debug!("TextRunScanner: pushing box(es) in range: %?", self.clump); - let new_box = layout::text::adapt_textbox_with_range(in_boxes[self.clump.begin()].d(), run, - Range(0, run.text.len())); - out_boxes.push(new_box); + for self.clump.eachi |i| { + let range = new_ranges[i - self.clump.begin()]; + if range.length() == 0 { loop } // XXX + let new_box = layout::text::adapt_textbox_with_range(in_boxes[i].d(), run, range); + out_boxes.push(new_box); + } } } /* /match */ diff --git a/src/servo/util/range.rs b/src/servo/util/range.rs index 71b22e1342c..4e236775bdb 100644 --- a/src/servo/util/range.rs +++ b/src/servo/util/range.rs @@ -83,6 +83,24 @@ pub impl Range { fail fmt!("relation_to_range(): didn't classify self=%?, other=%?", self, other); } + + fn repair_after_coalesced_range(&self, other: Range) -> Range { + let relation = self.relation_to_range(other); + debug!("repair_after_coalesced_range: possibly repairing range %?", self); + debug!("repair_after_coalesced_range: relation of original range and coalesced range(%?): %?", + other, relation); + let new_range = match relation { + EntirelyBefore => { *self }, + EntirelyAfter => { self.shift_by(-(other.length() as int)) }, + Coincides | ContainedBy => { Range(other.begin(), 1) }, + Contains => { self.extend_by(-(other.length() as int)) }, + OverlapsBegin(overlap) => { self.extend_by(1 - (overlap as int)) }, + OverlapsEnd(overlap) => + { Range(other.begin(), self.length() - overlap + 1) } + }; + debug!("repair_after_coalesced_range: new range: ---- %?", new_range); + new_range + } } pub pure fn empty_mut() -> MutableRange { MutableRange(0,0) }