Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-20 16:55:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

servo: Merge #3424 - Add font-size absolute size keywords. Fix #3417 (from SimonSapin:font-size-absolute)

Browse Source 
Source-Repo: https://github.com/servo/servo
Source-Revision: 08e004d10650f36af60818fd3c57ca461a97a678
This commit is contained in:
Simon Sapin 2014-09-19 15:17:55 -07:00
parent fe9ce360f4
commit ef153c16e8
11 changed files with 70 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
servo/components/layout/block.rs
View File

@ -38,9 +38,9 @@ use gfx::display_list::{RootOfStackingContextLevel};
use gfx::render_task::RenderLayer;
use servo_msg::compositor_msg::{FixedPosition, LayerId, Scrollable};
use servo_util::geometry::Au;
use servo_util::geometry;
use servo_util::logical_geometry::WritingMode;
use servo_util::logical_geometry::{LogicalPoint, LogicalRect, LogicalSize};
use std::cmp::{max, min};
use std::fmt;
use std::mem;
use style::computed_values::{LPA_Auto, LPA_Length, LPA_Percentage, LPN_Length, LPN_None};
@ -723,8 +723,8 @@ impl BlockFlow {
/// This is where we use the preferred inline-sizes and minimum inline-sizes
/// calculated in the bubble-inline-sizes traversal.
fn get_shrink_to_fit_inline_size(&self, available_inline_size: Au) -> Au {
geometry::min(self.base.intrinsic_inline_sizes.preferred_inline_size,
geometry::max(self.base.intrinsic_inline_sizes.minimum_inline_size, available_inline_size))
min(self.base.intrinsic_inline_sizes.preferred_inline_size,
max(self.base.intrinsic_inline_sizes.minimum_inline_size, available_inline_size))
}
/// Collect and update static y-offsets bubbled up by kids.
@ -1090,7 +1090,7 @@ impl BlockFlow {
// Intrinsic height should include floating descendants with a margin
// below the element's bottom edge (see CSS Section 10.6.7).
let content_block_size = geometry::max(
let content_block_size = max(
cur_b - block_start_offset,
floats.clearance(ClearBoth));
@ -1509,13 +1509,13 @@ impl Flow for BlockFlow {
if !fixed_width {
intrinsic_inline_sizes.minimum_inline_size =
geometry::max(intrinsic_inline_sizes.minimum_inline_size,
max(intrinsic_inline_sizes.minimum_inline_size,
child_base.intrinsic_inline_sizes.total_minimum_inline_size());
match float_kind {
float::none => {
intrinsic_inline_sizes.preferred_inline_size =
geometry::max(intrinsic_inline_sizes.preferred_inline_size,
max(intrinsic_inline_sizes.preferred_inline_size,
child_base.intrinsic_inline_sizes.total_preferred_inline_size());
}
float::left => {
@ -1533,13 +1533,13 @@ impl Flow for BlockFlow {
}
intrinsic_inline_sizes.preferred_inline_size =
geometry::max(intrinsic_inline_sizes.preferred_inline_size,
max(intrinsic_inline_sizes.preferred_inline_size,
left_float_width + right_float_width);
let fragment_intrinsic_inline_sizes = self.fragment.intrinsic_inline_sizes();
intrinsic_inline_sizes.minimum_inline_size = geometry::max(intrinsic_inline_sizes.minimum_inline_size,
intrinsic_inline_sizes.minimum_inline_size = max(intrinsic_inline_sizes.minimum_inline_size,
fragment_intrinsic_inline_sizes.minimum_inline_size);
intrinsic_inline_sizes.preferred_inline_size = geometry::max(intrinsic_inline_sizes.preferred_inline_size,
intrinsic_inline_sizes.preferred_inline_size = max(intrinsic_inline_sizes.preferred_inline_size,
fragment_intrinsic_inline_sizes.preferred_inline_size);
intrinsic_inline_sizes.surround_inline_size = fragment_intrinsic_inline_sizes.surround_inline_size;
self.base.intrinsic_inline_sizes = intrinsic_inline_sizes;

3
servo/components/layout/floats.rs
View File

@ -2,9 +2,10 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use servo_util::geometry::{Au, max, min};
use servo_util::geometry::Au;
use servo_util::logical_geometry::WritingMode;
use servo_util::logical_geometry::{LogicalPoint, LogicalRect, LogicalSize};
use std::cmp::{max, min};
use std::i32;
use std::fmt;
use style::computed_values::float;

13
servo/components/layout/fragment.rs
View File

@ -46,6 +46,7 @@ use servo_util::range::*;
use servo_util::namespace;
use servo_util::smallvec::SmallVec;
use servo_util::str::is_whitespace;
use std::cmp::{max, min};
use std::fmt;
use std::from_str::FromStr;
use std::mem;
@ -1168,17 +1169,17 @@ impl Fragment {
TableWrapperFragment => {}
InlineBlockFragment(ref mut info) => {
let block_flow = info.flow_ref.get_mut().as_block();
result.minimum_inline_size = geometry::max(result.minimum_inline_size,
result.minimum_inline_size = max(result.minimum_inline_size,
block_flow.base.intrinsic_inline_sizes.minimum_inline_size +
block_flow.base.intrinsic_inline_sizes.surround_inline_size);
result.preferred_inline_size = geometry::max(result.preferred_inline_size,
result.preferred_inline_size = max(result.preferred_inline_size,
block_flow.base.intrinsic_inline_sizes.preferred_inline_size +
block_flow.base.intrinsic_inline_sizes.surround_inline_size);
},
ImageFragment(ref mut image_fragment_info) => {
let image_inline_size = image_fragment_info.image_inline_size();
result.minimum_inline_size = geometry::max(result.minimum_inline_size, image_inline_size);
result.preferred_inline_size = geometry::max(result.preferred_inline_size, image_inline_size);
result.minimum_inline_size = max(result.minimum_inline_size, image_inline_size);
result.preferred_inline_size = max(result.preferred_inline_size, image_inline_size);
}
ScannedTextFragment(ref text_fragment_info) => {
let range = &text_fragment_info.range;
@ -1188,8 +1189,8 @@ impl Fragment {
// TODO: Account for soft wrap opportunities.
let max_line_inline_size = text_fragment_info.run.metrics_for_range(range).advance_width;
result.minimum_inline_size = geometry::max(result.minimum_inline_size, min_line_inline_size);
result.preferred_inline_size = geometry::max(result.preferred_inline_size, max_line_inline_size);
result.minimum_inline_size = max(result.minimum_inline_size, min_line_inline_size);
result.preferred_inline_size = max(result.preferred_inline_size, max_line_inline_size);
}
UnscannedTextFragment(..) => fail!("Unscanned text fragments should have been scanned by now!"),
}

4
servo/components/layout/inline.rs
View File

@ -23,10 +23,10 @@ use gfx::font_context::FontContext;
use geom::Size2D;
use gfx::text::glyph::CharIndex;
use servo_util::geometry::Au;
use servo_util::geometry;
use servo_util::logical_geometry::{LogicalRect, LogicalSize};
use servo_util::range;
use servo_util::range::{EachIndex, Range, RangeIndex, IntRangeIndex};
use std::cmp::max;
use std::fmt;
use std::mem;
use std::num;
@ -928,7 +928,7 @@ impl Flow for InlineFlow {
let fragment_intrinsic_inline_sizes =
fragment.intrinsic_inline_sizes();
intrinsic_inline_sizes.minimum_inline_size = geometry::max(
intrinsic_inline_sizes.minimum_inline_size = max(
intrinsic_inline_sizes.minimum_inline_size,
fragment_intrinsic_inline_sizes.minimum_inline_size);
intrinsic_inline_sizes.preferred_inline_size =

6
servo/components/layout/model.rs
View File

@ -13,8 +13,8 @@ use geom::SideOffsets2D;
use style::computed_values::{LPA_Auto, LPA_Length, LPA_Percentage, LP_Length, LP_Percentage};
use style::ComputedValues;
use servo_util::geometry::Au;
use servo_util::geometry;
use servo_util::logical_geometry::LogicalMargin;
use std::cmp::{max, min};
use std::fmt;
/// A collapsible margin. See CSS 2.1 § 8.3.1.
@ -50,8 +50,8 @@ impl AdjoiningMargins {
}
pub fn union(&mut self, other: AdjoiningMargins) {
self.most_positive = geometry::max(self.most_positive, other.most_positive);
self.most_negative = geometry::min(self.most_negative, other.most_negative)
self.most_positive = max(self.most_positive, other.most_positive);
self.most_negative = min(self.most_negative, other.most_negative)
}
pub fn collapse(&self) -> Au {

6
servo/components/layout/table.rs
View File

@ -17,8 +17,8 @@ use table_wrapper::{TableLayout, FixedLayout, AutoLayout};
use wrapper::ThreadSafeLayoutNode;
use servo_util::geometry::Au;
use servo_util::geometry;
use servo_util::logical_geometry::LogicalRect;
use std::cmp::max;
use std::fmt;
use style::computed_values::table_layout;
@ -233,7 +233,7 @@ impl Flow for TableFlow {
let fragment_intrinsic_inline_sizes = self.block_flow.fragment.intrinsic_inline_sizes();
self.block_flow.base.intrinsic_inline_sizes.minimum_inline_size = min_inline_size;
self.block_flow.base.intrinsic_inline_sizes.preferred_inline_size =
geometry::max(min_inline_size, pref_inline_size);
max(min_inline_size, pref_inline_size);
self.block_flow.base.intrinsic_inline_sizes.surround_inline_size =
fragment_intrinsic_inline_sizes.surround_inline_size;
}
@ -273,7 +273,7 @@ impl Flow for TableFlow {
*col_inline_size = (*col_inline_size).scale_by(ratio);
}
} else if num_unspecified_inline_sizes != 0 {
let extra_column_inline_size = (content_inline_size - total_column_inline_size) / Au::new(num_unspecified_inline_sizes);
let extra_column_inline_size = (content_inline_size - total_column_inline_size) / num_unspecified_inline_sizes;
for col_inline_size in self.col_inline_sizes.mut_iter() {
if *col_inline_size == Au(0) {
*col_inline_size = extra_column_inline_size;

12
servo/components/layout/table_row.rs
View File

@ -18,7 +18,7 @@ use model::{MaybeAuto, Specified, Auto};
use wrapper::ThreadSafeLayoutNode;
use servo_util::geometry::Au;
use servo_util::geometry;
use std::cmp::max;
use std::fmt;
/// A table formatting context.
@ -91,19 +91,19 @@ impl TableRowFlow {
let child_specified_block_size = MaybeAuto::from_style(child_fragment.style().content_block_size(),
Au::new(0)).specified_or_zero();
max_y =
geometry::max(max_y,
max(max_y,
child_specified_block_size + child_fragment.border_padding.block_start_end());
}
let child_node = flow::mut_base(kid);
child_node.position.start.b = cur_y;
max_y = geometry::max(max_y, child_node.position.size.block);
max_y = max(max_y, child_node.position.size.block);
}
let mut block_size = max_y;
// TODO: Percentage block-size
block_size = match MaybeAuto::from_style(self.block_flow.fragment.style().content_block_size(), Au(0)) {
Auto => block_size,
Specified(value) => geometry::max(value, block_size)
Specified(value) => max(value, block_size)
};
// cur_y = cur_y + block-size;
@ -188,8 +188,8 @@ impl Flow for TableRowFlow {
pref_inline_size = pref_inline_size + child_base.intrinsic_inline_sizes.preferred_inline_size;
}
self.block_flow.base.intrinsic_inline_sizes.minimum_inline_size = min_inline_size;
self.block_flow.base.intrinsic_inline_sizes.preferred_inline_size = geometry::max(min_inline_size,
pref_inline_size);
self.block_flow.base.intrinsic_inline_sizes.preferred_inline_size = max(
min_inline_size, pref_inline_size);
}
/// Recursively (top-down) determines the actual inline-size of child contexts and fragments. When called

6
servo/components/layout/table_rowgroup.rs
View File

@ -17,7 +17,7 @@ use table::{InternalTable, TableFlow};
use wrapper::ThreadSafeLayoutNode;
use servo_util::geometry::Au;
use servo_util::geometry;
use std::cmp::max;
use std::fmt;
/// A table formatting context.
@ -169,8 +169,8 @@ impl Flow for TableRowGroupFlow {
}
self.block_flow.base.intrinsic_inline_sizes.minimum_inline_size = min_inline_size;
self.block_flow.base.intrinsic_inline_sizes.preferred_inline_size = geometry::max(min_inline_size,
pref_inline_size);
self.block_flow.base.intrinsic_inline_sizes.preferred_inline_size = max(
min_inline_size, pref_inline_size);
}
/// Recursively (top-down) determines the actual inline-size of child contexts and fragments. When

10
servo/components/layout/table_wrapper.rs
View File

@ -17,7 +17,7 @@ use model::{Specified, Auto, specified};
use wrapper::ThreadSafeLayoutNode;
use servo_util::geometry::Au;
use servo_util::geometry;
use std::cmp::max;
use std::fmt;
use style::computed_values::table_layout;
@ -250,7 +250,7 @@ impl TableWrapper {
// Compare border-edge inline-sizes. Because fixed_cells_inline-size indicates content-inline-size,
// padding and border values are added to fixed_cells_inline-size.
computed_inline_size = geometry::max(
computed_inline_size = max(
fixed_cells_inline_size + padding_and_borders, computed_inline_size);
computed_inline_size
},
@ -276,7 +276,7 @@ impl TableWrapper {
// required by all columns. It will be distributed over the columns.
let (inline_size, extra_inline_size) = match input.computed_inline_size {
Auto => {
if input.available_inline_size > geometry::max(cols_max, cap_min) {
if input.available_inline_size > max(cols_max, cap_min) {
if cols_max > cap_min {
table_wrapper.col_inline_sizes = col_pref_inline_sizes.clone();
(cols_max, Au(0))
@ -288,7 +288,7 @@ impl TableWrapper {
table_wrapper.col_inline_sizes = col_min_inline_sizes.clone();
cols_min
} else {
geometry::max(input.available_inline_size, cap_min)
max(input.available_inline_size, cap_min)
};
(max, max - cols_min)
}
@ -298,7 +298,7 @@ impl TableWrapper {
table_wrapper.col_inline_sizes = col_min_inline_sizes.clone();
cols_min
} else {
geometry::max(inline_size, cap_min)
max(inline_size, cap_min)
};
(max, max - cols_min)
}

29
servo/components/style/properties/mod.rs.mako
View File

@ -904,8 +904,9 @@ pub mod longhands {
use super::super::Au;
pub type T = Au;
}
static MEDIUM_PX: int = 16;
#[inline] pub fn get_initial_value() -> computed_value::T {
Au::from_px(16) // medium
Au::from_px(MEDIUM_PX)
}
#[inline]
pub fn to_computed_value(_value: SpecifiedValue, context: &computed::Context)
@ -913,16 +914,26 @@ pub mod longhands {
// We already computed this element's font size; no need to compute it again.
return context.font_size
}
/// <length> | <percentage>
/// TODO: support <absolute-size> and <relative-size>
/// <length> | <percentage> | <absolute-size>
/// TODO: support <relative-size>
pub fn from_component_value(input: &ComponentValue, _base_url: &Url)
-> Result<SpecifiedValue, ()> {
specified::LengthOrPercentage::parse_non_negative(input).map(|value| {
match value {
specified::LP_Length(value) => value,
specified::LP_Percentage(value) => specified::Em(value),
}
})
match specified::LengthOrPercentage::parse_non_negative(input) {
Ok(specified::LP_Length(value)) => return Ok(value),
Ok(specified::LP_Percentage(value)) => return Ok(specified::Em(value)),
Err(()) => (),
}
let au = match try!(get_ident_lower(input)).as_slice() {
"xx-small" => Au::from_px(MEDIUM_PX) * 3 / 5,
"x-small" => Au::from_px(MEDIUM_PX) * 3 / 4,
"small" => Au::from_px(MEDIUM_PX) * 8 / 9,
"medium" => Au::from_px(MEDIUM_PX),
"large" => Au::from_px(MEDIUM_PX) * 6 / 5,
"x-large" => Au::from_px(MEDIUM_PX) * 3 / 2,
"xx-large" => Au::from_px(MEDIUM_PX) * 2,
_ => return Err(())
};
Ok(specified::Au_(au))
}
</%self:single_component_value>

34
servo/components/util/geometry.rs
View File

@ -9,7 +9,7 @@ use geom::size::Size2D;
use serialize::{Encodable, Encoder};
use std::default::Default;
use std::num::{NumCast, One, Zero};
use std::num::{NumCast, Zero};
use std::fmt;
// Units for use with geom::length and geom::scale_factor.
@ -102,30 +102,27 @@ impl Sub<Au,Au> for Au {
}
impl Mul<Au,Au> for Au {
impl Mul<i32, Au> for Au {
#[inline]
fn mul(&self, other: &Au) -> Au {
fn mul(&self, other: &i32) -> Au {
let Au(s) = *self;
let Au(o) = *other;
Au(s * o)
Au(s * *other)
}
}
impl Div<Au,Au> for Au {
impl Div<i32, Au> for Au {
#[inline]
fn div(&self, other: &Au) -> Au {
fn div(&self, other: &i32) -> Au {
let Au(s) = *self;
let Au(o) = *other;
Au(s / o)
Au(s / *other)
}
}
impl Rem<Au,Au> for Au {
impl Rem<i32, Au> for Au {
#[inline]
fn rem(&self, other: &Au) -> Au {
fn rem(&self, other: &i32) -> Au {
let Au(s) = *self;
let Au(o) = *other;
Au(s % o)
Au(s % *other)
}
}
@ -137,17 +134,6 @@ impl Neg<Au> for Au {
}
}
impl One for Au {
#[inline]
fn one() -> Au { Au(1) }
}
impl Num for Au {}
#[inline]
pub fn min(x: Au, y: Au) -> Au { if x < y { x } else { y } }
#[inline]
pub fn max(x: Au, y: Au) -> Au { if x > y { x } else { y } }
impl NumCast for Au {
#[inline]