aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/components/gfx/display_list.rs2
-rw-r--r--src/components/gfx/font.rs6
-rw-r--r--src/components/gfx/text/glyph.rs2
-rw-r--r--src/components/gfx/text/shaping/harfbuzz.rs4
-rw-r--r--src/components/gfx/text/text_run.rs26
-rw-r--r--src/components/main/layout/box_.rs8
-rw-r--r--src/components/main/layout/construct.rs2
-rw-r--r--src/components/main/layout/inline.rs8
-rw-r--r--src/components/main/layout/text.rs4
-rw-r--r--src/components/util/range.rs78
10 files changed, 75 insertions, 65 deletions
diff --git a/src/components/gfx/display_list.rs b/src/components/gfx/display_list.rs
index f9bbe54e5b6..336436fa183 100644
--- a/src/components/gfx/display_list.rs
+++ b/src/components/gfx/display_list.rs
@@ -395,7 +395,7 @@ pub struct TextDisplayItem {
pub text_run: Arc<~TextRun>,
/// The range of text within the text run.
- pub range: Range,
+ pub range: Range<uint>,
/// The color of the text.
pub text_color: Color,
diff --git a/src/components/gfx/font.rs b/src/components/gfx/font.rs
index c4ec741e32b..7a15ef91a17 100644
--- a/src/components/gfx/font.rs
+++ b/src/components/gfx/font.rs
@@ -330,7 +330,7 @@ impl Font {
pub fn draw_text_into_context(&mut self,
rctx: &RenderContext,
run: &~TextRun,
- range: &Range,
+ range: &Range<uint>,
baseline_origin: Point2D<Au>,
color: Color) {
use libc::types::common::c99::{uint16_t, uint32_t};
@@ -391,7 +391,7 @@ impl Font {
}
}
- pub fn measure_text(&self, run: &TextRun, range: &Range) -> RunMetrics {
+ pub fn measure_text(&self, run: &TextRun, range: &Range<uint>) -> RunMetrics {
// TODO(Issue #199): alter advance direction for RTL
// TODO(Issue #98): using inter-char and inter-word spacing settings when measuring text
let mut advance = Au(0);
@@ -405,7 +405,7 @@ impl Font {
pub fn measure_text_for_slice(&self,
glyphs: &GlyphStore,
- slice_range: &Range)
+ slice_range: &Range<uint>)
-> RunMetrics {
let mut advance = Au(0);
for (_i, glyph) in glyphs.iter_glyphs_for_char_range(slice_range) {
diff --git a/src/components/gfx/text/glyph.rs b/src/components/gfx/text/glyph.rs
index 2e6098e9fa3..14bca394ad7 100644
--- a/src/components/gfx/text/glyph.rs
+++ b/src/components/gfx/text/glyph.rs
@@ -598,7 +598,7 @@ impl<'a> GlyphStore {
}
#[inline]
- pub fn iter_glyphs_for_char_range(&'a self, rang: &Range) -> GlyphIterator<'a> {
+ pub fn iter_glyphs_for_char_range(&'a self, rang: &Range<uint>) -> GlyphIterator<'a> {
if rang.begin() >= self.entry_buffer.len() {
fail!("iter_glyphs_for_range: range.begin beyond length!");
}
diff --git a/src/components/gfx/text/shaping/harfbuzz.rs b/src/components/gfx/text/shaping/harfbuzz.rs
index 6a89a335911..0e125610c47 100644
--- a/src/components/gfx/text/shaping/harfbuzz.rs
+++ b/src/components/gfx/text/shaping/harfbuzz.rs
@@ -276,10 +276,10 @@ impl Shaper {
}
// some helpers
- let mut glyph_span: Range = Range::empty();
+ let mut glyph_span: Range<uint> = Range::empty();
// this span contains first byte of first char, to last byte of last char in range.
// so, end() points to first byte of last+1 char, if it's less than byte_max.
- let mut char_byte_span: Range = Range::empty();
+ let mut char_byte_span: Range<uint> = Range::empty();
let mut y_pos = Au(0);
// main loop over each glyph. each iteration usually processes 1 glyph and 1+ chars.
diff --git a/src/components/gfx/text/text_run.rs b/src/components/gfx/text/text_run.rs
index 2b6c2a37368..b0f2ee566f8 100644
--- a/src/components/gfx/text/text_run.rs
+++ b/src/components/gfx/text/text_run.rs
@@ -23,14 +23,14 @@ pub struct TextRun {
pub struct SliceIterator<'a> {
glyph_iter: Items<'a, Arc<GlyphStore>>,
- range: Range,
+ range: Range<uint>,
offset: uint,
}
-impl<'a> Iterator<(&'a GlyphStore, uint, Range)> for SliceIterator<'a> {
+impl<'a> Iterator<(&'a GlyphStore, uint, Range<uint>)> for SliceIterator<'a> {
// inline(always) due to the inefficient rt failures messing up inline heuristics, I think.
#[inline(always)]
- fn next(&mut self) -> Option<(&'a GlyphStore, uint, Range)> {
+ fn next(&mut self) -> Option<(&'a GlyphStore, uint, Range<uint>)> {
loop {
let slice_glyphs = self.glyph_iter.next();
if slice_glyphs.is_none() {
@@ -52,13 +52,13 @@ impl<'a> Iterator<(&'a GlyphStore, uint, Range)> for SliceIterator<'a> {
}
pub struct LineIterator<'a> {
- range: Range,
- clump: Option<Range>,
+ range: Range<uint>,
+ clump: Option<Range<uint>>,
slices: SliceIterator<'a>,
}
-impl<'a> Iterator<Range> for LineIterator<'a> {
- fn next(&mut self) -> Option<Range> {
+impl<'a> Iterator<Range<uint>> for LineIterator<'a> {
+ fn next(&mut self) -> Option<Range<uint>> {
// Loop until we hit whitespace and are in a clump.
loop {
match self.slices.next() {
@@ -175,14 +175,14 @@ impl<'a> TextRun {
&*self.glyphs
}
- pub fn range_is_trimmable_whitespace(&self, range: &Range) -> bool {
+ pub fn range_is_trimmable_whitespace(&self, range: &Range<uint>) -> bool {
for (slice_glyphs, _, _) in self.iter_slices_for_range(range) {
if !slice_glyphs.is_whitespace() { return false; }
}
true
}
- pub fn metrics_for_range(&self, range: &Range) -> RunMetrics {
+ pub fn metrics_for_range(&self, range: &Range<uint>) -> RunMetrics {
// TODO(Issue #199): alter advance direction for RTL
// TODO(Issue #98): using inter-char and inter-word spacing settings when measuring text
let mut advance = Au(0);
@@ -194,14 +194,14 @@ impl<'a> TextRun {
RunMetrics::new(advance, self.font_metrics.ascent, self.font_metrics.descent)
}
- pub fn metrics_for_slice(&self, glyphs: &GlyphStore, slice_range: &Range) -> RunMetrics {
+ pub fn metrics_for_slice(&self, glyphs: &GlyphStore, slice_range: &Range<uint>) -> RunMetrics {
let mut advance = Au(0);
for (_i, glyph) in glyphs.iter_glyphs_for_char_range(slice_range) {
advance = advance + glyph.advance();
}
RunMetrics::new(advance, self.font_metrics.ascent, self.font_metrics.descent)
}
- pub fn min_width_for_range(&self, range: &Range) -> Au {
+ pub fn min_width_for_range(&self, range: &Range<uint>) -> Au {
let mut max_piece_width = Au(0);
debug!("iterating outer range {:?}", range);
for (_, offset, slice_range) in self.iter_slices_for_range(range) {
@@ -212,7 +212,7 @@ impl<'a> TextRun {
max_piece_width
}
- pub fn iter_slices_for_range(&'a self, range: &Range) -> SliceIterator<'a> {
+ pub fn iter_slices_for_range(&'a self, range: &Range<uint>) -> SliceIterator<'a> {
SliceIterator {
glyph_iter: self.glyphs.iter(),
range: *range,
@@ -220,7 +220,7 @@ impl<'a> TextRun {
}
}
- pub fn iter_natural_lines_for_range(&'a self, range: &Range) -> LineIterator<'a> {
+ pub fn iter_natural_lines_for_range(&'a self, range: &Range<uint>) -> LineIterator<'a> {
LineIterator {
range: *range,
clump: None,
diff --git a/src/components/main/layout/box_.rs b/src/components/main/layout/box_.rs
index 416e9400106..d9484ba72ff 100644
--- a/src/components/main/layout/box_.rs
+++ b/src/components/main/layout/box_.rs
@@ -226,12 +226,12 @@ pub struct ScannedTextBoxInfo {
pub run: Arc<~TextRun>,
/// The range within the above text run that this represents.
- pub range: Range,
+ pub range: Range<uint>,
}
impl ScannedTextBoxInfo {
/// Creates the information specific to a scanned text box from a range and a text run.
- pub fn new(run: Arc<~TextRun>, range: Range) -> ScannedTextBoxInfo {
+ pub fn new(run: Arc<~TextRun>, range: Range<uint>) -> ScannedTextBoxInfo {
ScannedTextBoxInfo {
run: run,
range: range,
@@ -1146,7 +1146,7 @@ impl Box {
let mut pieces_processed_count: uint = 0;
let mut remaining_width: Au = max_width;
let mut left_range = Range::new(text_box_info.range.begin(), 0);
- let mut right_range: Option<Range> = None;
+ let mut right_range: Option<Range<uint>> = None;
debug!("split_to_width: splitting text box (strlen={:u}, range={}, \
avail_width={})",
@@ -1222,7 +1222,7 @@ impl Box {
None
};
- let right_box = right_range.map_or(None, |range: Range| {
+ let right_box = right_range.map_or(None, |range: Range<uint>| {
let new_text_box_info = ScannedTextBoxInfo::new(text_box_info.run.clone(),
range);
let mut new_metrics = new_text_box_info.run.metrics_for_range(&range);
diff --git a/src/components/main/layout/construct.rs b/src/components/main/layout/construct.rs
index e7523039551..a2236b6753d 100644
--- a/src/components/main/layout/construct.rs
+++ b/src/components/main/layout/construct.rs
@@ -189,7 +189,7 @@ impl InlineBoxAccumulator {
fn from_inline_node(node: &ThreadSafeLayoutNode) -> InlineBoxAccumulator {
let mut boxes = InlineBoxes::new();
- boxes.map.push(node.style().clone(), Range::new(0, 0));
+ boxes.map.push(node.style().clone(), Range::new(0u, 0));
InlineBoxAccumulator {
boxes: boxes,
has_enclosing_range: true,
diff --git a/src/components/main/layout/inline.rs b/src/components/main/layout/inline.rs
index 773618f9032..477018bfb5a 100644
--- a/src/components/main/layout/inline.rs
+++ b/src/components/main/layout/inline.rs
@@ -56,7 +56,7 @@ use sync::Arc;
/// left corner of the green zone is the same as that of the line, but
/// the green zone can be taller and wider than the line itself.
pub struct LineBox {
- pub range: Range,
+ pub range: Range<uint>,
pub bounds: Rect<Au>,
pub green_zone: Size2D<Au>
}
@@ -977,12 +977,12 @@ pub struct FragmentRange {
/// The style of the DOM node that this range refers to.
pub style: Arc<ComputedValues>,
/// The range, in indices into the fragment list.
- pub range: Range,
+ pub range: Range<uint>,
}
impl FragmentRange {
/// Creates a new fragment range from the given values.
- fn new(style: Arc<ComputedValues>, range: Range) -> FragmentRange {
+ fn new(style: Arc<ComputedValues>, range: Range<uint>) -> FragmentRange {
FragmentRange {
style: style,
range: range,
@@ -1053,7 +1053,7 @@ impl FragmentMap {
}
/// Adds the given node to the fragment map.
- pub fn push(&mut self, style: Arc<ComputedValues>, range: Range) {
+ pub fn push(&mut self, style: Arc<ComputedValues>, range: Range<uint>) {
self.list.push(FragmentRange::new(style, range))
}
diff --git a/src/components/main/layout/text.rs b/src/components/main/layout/text.rs
index c70aa8c0cb1..83dfb9d1b78 100644
--- a/src/components/main/layout/text.rs
+++ b/src/components/main/layout/text.rs
@@ -31,7 +31,7 @@ fn can_coalesce_text_nodes(boxes: &[Box], left_i: uint, right_i: uint) -> bool {
/// A stack-allocated object for scanning an inline flow into `TextRun`-containing `TextBox`es.
pub struct TextRunScanner {
- pub clump: Range,
+ pub clump: Range<uint>,
}
impl TextRunScanner {
@@ -210,7 +210,7 @@ impl TextRunScanner {
// Next, concatenate all of the transformed strings together, saving the new
// character indices.
let mut run_str: ~str = "".to_owned();
- let mut new_ranges: Vec<Range> = vec!();
+ let mut new_ranges: Vec<Range<uint>> = vec!();
let mut char_total = 0;
for i in range(0, transformed_strs.len()) {
let added_chars = transformed_strs.get(i).char_len();
diff --git a/src/components/util/range.rs b/src/components/util/range.rs
index e7cbb52117b..3f9eb33914f 100644
--- a/src/components/util/range.rs
+++ b/src/components/util/range.rs
@@ -5,10 +5,12 @@
use std::cmp::{max, min};
use std::iter;
use std::fmt;
+use std::num;
+use std::num::Bounded;
-pub enum RangeRelation {
- OverlapsBegin(/* overlap */ uint),
- OverlapsEnd(/* overlap */ uint),
+pub enum RangeRelation<T> {
+ OverlapsBegin(/* overlap */ T),
+ OverlapsEnd(/* overlap */ T),
ContainedBy,
Contains,
Coincides,
@@ -17,20 +19,20 @@ pub enum RangeRelation {
}
#[deriving(Clone)]
-pub struct Range {
- off: uint,
- len: uint
+pub struct Range<T> {
+ off: T,
+ len: T,
}
-impl fmt::Show for Range {
+impl<T: Int + TotalOrd> fmt::Show for Range<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f.buf, "[{} .. {})", self.begin(), self.end())
}
}
-impl Range {
+impl<T: Int + TotalOrd> Range<T> {
#[inline]
- pub fn new(off: uint, len: uint) -> Range {
+ pub fn new(off: T, len: T) -> Range<T> {
Range {
off: off,
len: len,
@@ -38,68 +40,76 @@ impl Range {
}
#[inline]
- pub fn empty() -> Range {
- Range::new(0, 0)
+ pub fn empty() -> Range<T> {
+ Range::new(num::zero(), num::zero())
}
-}
-impl Range {
#[inline]
- pub fn begin(&self) -> uint { self.off }
+ pub fn begin(&self) -> T { self.off }
#[inline]
- pub fn length(&self) -> uint { self.len }
+ pub fn length(&self) -> T { self.len }
#[inline]
- pub fn end(&self) -> uint { self.off + self.len }
+ pub fn end(&self) -> T { self.off + self.len }
#[inline]
- pub fn eachi(&self) -> iter::Range<uint> {
+ pub fn eachi(&self) -> iter::Range<T> {
range(self.off, self.off + self.len)
}
#[inline]
- pub fn contains(&self, i: uint) -> bool {
+ pub fn contains(&self, i: T) -> bool {
i >= self.begin() && i < self.end()
}
#[inline]
pub fn is_valid_for_string(&self, s: &str) -> bool {
- self.begin() < s.len() && self.end() <= s.len() && self.length() <= s.len()
+ let s_len = s.len();
+ match num::cast(s_len) {
+ Some(len) => {
+ self.begin() < len && self.end() <= len && self.length() <= len
+ },
+ None => {
+ debug!("Range<T>::is_valid_for_string: string length ({}) is longer than the max \
+ value for T ({})", s_len, { let val: T = Bounded::max_value(); val });
+ false
+ },
+ }
}
#[inline]
pub fn is_empty(&self) -> bool {
- self.len == 0
+ self.len.is_zero()
}
#[inline]
pub fn shift_by(&mut self, i: int) {
- self.off = ((self.off as int) + i) as uint;
+ self.off = num::cast(self.off.to_int().unwrap() + i).unwrap();
}
#[inline]
pub fn extend_by(&mut self, i: int) {
- self.len = ((self.len as int) + i) as uint;
+ self.len = num::cast(self.len.to_int().unwrap() + i).unwrap();
}
#[inline]
- pub fn extend_to(&mut self, i: uint) {
+ pub fn extend_to(&mut self, i: T) {
self.len = i - self.off;
}
#[inline]
pub fn adjust_by(&mut self, off_i: int, len_i: int) {
- self.off = ((self.off as int) + off_i) as uint;
- self.len = ((self.len as int) + len_i) as uint;
+ self.off = num::cast(self.off.to_int().unwrap() + off_i).unwrap();
+ self.len = num::cast(self.len.to_int().unwrap() + len_i).unwrap();
}
#[inline]
- pub fn reset(&mut self, off_i: uint, len_i: uint) {
+ pub fn reset(&mut self, off_i: T, len_i: T) {
self.off = off_i;
self.len = len_i;
}
#[inline]
- pub fn intersect(&self, other: &Range) -> Range {
+ pub fn intersect(&self, other: &Range<T>) -> Range<T> {
let begin = max(self.begin(), other.begin());
let end = min(self.end(), other.end());
@@ -114,7 +124,7 @@ impl Range {
/// from the point of view of `self`. So, 'EntirelyBefore' means
/// that the `self` range is entirely before `other` range.
#[inline]
- pub fn relation_to_range(&self, other: &Range) -> RangeRelation {
+ pub fn relation_to_range(&self, other: &Range<T>) -> RangeRelation<T> {
if other.begin() > self.end() {
return EntirelyBefore;
}
@@ -143,19 +153,19 @@ impl Range {
}
#[inline]
- pub fn repair_after_coalesced_range(&mut self, other: &Range) {
+ pub fn repair_after_coalesced_range(&mut self, other: &Range<T>) {
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);
match relation {
EntirelyBefore => { },
- EntirelyAfter => { self.shift_by(-(other.length() as int)); },
- Coincides | ContainedBy => { self.reset(other.begin(), 1); },
- Contains => { self.extend_by(-(other.length() as int)); },
- OverlapsBegin(overlap) => { self.extend_by(1 - (overlap as int)); },
+ EntirelyAfter => { self.shift_by(-other.length().to_int().unwrap()); },
+ Coincides | ContainedBy => { self.reset(other.begin(), num::one()); },
+ Contains => { self.extend_by(-other.length().to_int().unwrap()); },
+ OverlapsBegin(overlap) => { self.extend_by(1 - overlap.to_int().unwrap()); },
OverlapsEnd(overlap) => {
- let len = self.length() - overlap + 1;
+ let len = self.length() - overlap + num::one();
self.reset(other.begin(), len);
}
};
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-30 12:23:31 +0000