Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-07 06:25:32 +01:00
Code Issues Projects Releases Packages Wiki Activity

style: Use less Au in font code.

Browse source 
Font code is the only thing that was using Au in the style system without
interfacing with Gecko, and there was no real reason for it to do so.

This slightly simplifies the code.

Differential Revision: https://phabricator.services.mozilla.com/D57248
This commit is contained in:
Emilio Cobos Álvarez 2019-12-15 20:15:29 +01:00
parent 4cd8813a81
commit a541046147
13 changed files with 62 additions and 89 deletions
Download patch file Download diff file Expand all files Collapse all files

8
components/style/values/computed/font.rs
View file

@ -21,7 +21,6 @@ use crate::values::specified::font::{
use crate::values::specified::length::{FontBaseSize, NoCalcLength};
use crate::values::CSSFloat;
use crate::Atom;
use app_units::Au;
use byteorder::{BigEndian, ByteOrder};
use cssparser::{serialize_identifier, CssStringWriter, Parser};
#[cfg(feature = "gecko")]
@ -148,15 +147,16 @@ impl FontWeight {
impl FontSize {
/// The actual computed font size.
pub fn size(self) -> Au {
self.size.into()
#[inline]
pub fn size(&self) -> Length {
self.size.0
}
#[inline]
/// Get default value of font size.
pub fn medium() -> Self {
Self {
size: Au::from_px(specified::FONT_MEDIUM_PX).into(),
size: NonNegative(Length::new(specified::FONT_MEDIUM_PX as CSSFloat)),
keyword_info: Some(KeywordInfo::medium()),
}
}

2
components/style/values/computed/length.rs
View file

@ -29,7 +29,7 @@ pub use crate::values::specified::url::UrlOrNone;
pub use crate::values::specified::{Angle, BorderStyle, Time};
impl ToComputedValue for specified::NoCalcLength {
type ComputedValue = CSSPixelLength;
type ComputedValue = Length;
#[inline]
fn to_computed_value(&self, context: &Context) -> Self::ComputedValue {

40
components/style/values/specified/font.rs
View file

@ -20,7 +20,6 @@ use crate::values::specified::{AllowQuirks, Angle, Integer, LengthPercentage};
use crate::values::specified::{NoCalcLength, NonNegativeNumber, Number, Percentage};
use crate::values::CustomIdent;
use crate::Atom;
use app_units::Au;
use byteorder::{BigEndian, ByteOrder};
use cssparser::{Parser, Token};
#[cfg(feature = "gecko")]
@ -773,18 +772,18 @@ impl ToComputedValue for KeywordSize {
type ComputedValue = NonNegativeLength;
#[inline]
fn to_computed_value(&self, _: &Context) -> NonNegativeLength {
let medium = Length::new(FONT_MEDIUM_PX as f32);
// https://drafts.csswg.org/css-fonts-3/#font-size-prop
match *self {
KeywordSize::XXSmall => Au::from_px(FONT_MEDIUM_PX) * 3 / 5,
KeywordSize::XSmall => Au::from_px(FONT_MEDIUM_PX) * 3 / 4,
KeywordSize::Small => Au::from_px(FONT_MEDIUM_PX) * 8 / 9,
KeywordSize::Medium => Au::from_px(FONT_MEDIUM_PX),
KeywordSize::Large => Au::from_px(FONT_MEDIUM_PX) * 6 / 5,
KeywordSize::XLarge => Au::from_px(FONT_MEDIUM_PX) * 3 / 2,
KeywordSize::XXLarge => Au::from_px(FONT_MEDIUM_PX) * 2,
KeywordSize::XXXLarge => Au::from_px(FONT_MEDIUM_PX) * 3,
}
.into()
NonNegative(match *self {
KeywordSize::XXSmall => medium * 3.0 / 5.0,
KeywordSize::XSmall => medium * 3.0 / 4.0,
KeywordSize::Small => medium * 8.0 / 9.0,
KeywordSize::Medium => medium,
KeywordSize::Large => medium * 6.0 / 5.0,
KeywordSize::XLarge => medium * 3.0 / 2.0,
KeywordSize::XXLarge => medium * 2.0,
KeywordSize::XXXLarge => medium * 3.0,
})
}
#[inline]
@ -799,7 +798,6 @@ impl ToComputedValue for KeywordSize {
#[inline]
fn to_computed_value(&self, cx: &Context) -> NonNegativeLength {
use crate::context::QuirksMode;
use crate::values::specified::length::au_to_int_px;
// The tables in this function are originally from
// nsRuleNode::CalcFontPointSize in Gecko:
@ -850,22 +848,21 @@ impl ToComputedValue for KeywordSize {
Atom::with(gecko_font.mLanguage.mRawPtr, |atom| {
cx.font_metrics_provider
.get_size(atom, gecko_font.mGenericID)
.0
})
};
let base_size_px = au_to_int_px(base_size as f32);
let base_size_px = base_size.px().round() as i32;
let html_size = self.html_size() as usize;
if base_size_px >= 9 && base_size_px <= 16 {
NonNegative(if base_size_px >= 9 && base_size_px <= 16 {
let mapping = if cx.quirks_mode == QuirksMode::Quirks {
QUIRKS_FONT_SIZE_MAPPING
} else {
FONT_SIZE_MAPPING
};
Au::from_px(mapping[(base_size_px - 9) as usize][html_size]).into()
Length::new(mapping[(base_size_px - 9) as usize][html_size] as f32)
} else {
Au(FONT_SIZE_FACTORS[html_size] * base_size / 100).into()
}
base_size * FONT_SIZE_FACTORS[html_size] as f32 / 100.0
})
}
#[inline]
@ -927,7 +924,7 @@ impl FontSize {
// If the parent font was keyword-derived, this is too.
// Tack the % onto the factor
info = compose_keyword(pc.0);
base_size.resolve(context).scale_by(pc.0).into()
base_size.resolve(context) * pc.0
},
FontSize::Length(LengthPercentage::Calc(ref calc)) => {
let parent = context.style().get_parent_font().clone_font_size();
@ -964,8 +961,7 @@ impl FontSize {
// others should reject negatives during parsing. But SMIL
// allows parsing negatives, and relies on us _not_ doing that
// clamping. That's so bonkers :(
CSSPixelLength::from(calc.to_used_value(base_size.resolve(context)))
.clamp_to_non_negative()
calc.percentage_relative_to(base_size.resolve(context)).clamp_to_non_negative()
},
FontSize::Keyword(i) => {
// As a specified keyword, this is keyword derived

5
components/style/values/specified/gecko.rs
View file

@ -5,8 +5,7 @@
//! Specified types for legacy Gecko-only properties.
use crate::parser::{Parse, ParserContext};
use crate::values::computed::length::CSSPixelLength;
use crate::values::computed::{self, LengthPercentage};
use crate::values::computed::{self, LengthPercentage, Length};
use crate::values::generics::rect::Rect;
use cssparser::{Parser, Token};
use std::fmt;
@ -24,7 +23,7 @@ fn parse_pixel_or_percent<'i, 't>(
value, ref unit, ..
} => {
match_ignore_ascii_case! { unit,
"px" => Ok(LengthPercentage::new(CSSPixelLength::new(value), None)),
"px" => Ok(LengthPercentage::new(Length::new(value), None)),
_ => Err(()),
}
},

39
components/style/values/specified/length.rs
View file

@ -47,14 +47,6 @@ pub const AU_PER_PT: CSSFloat = AU_PER_IN / 72.;
/// Number of app units per pica
pub const AU_PER_PC: CSSFloat = AU_PER_PT * 12.;
/// Same as Gecko's AppUnitsToIntCSSPixels
///
/// Converts app units to integer pixel values,
/// rounding during the conversion
pub fn au_to_int_px(au: f32) -> i32 {
(au / AU_PER_PX).round() as i32
}
/// A font relative length.
#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, ToCss, ToShmem)]
pub enum FontRelativeLength {
@ -87,7 +79,7 @@ pub enum FontBaseSize {
impl FontBaseSize {
/// Calculate the actual size for a given context
pub fn resolve(&self, context: &Context) -> Au {
pub fn resolve(&self, context: &Context) -> computed::Length {
match *self {
FontBaseSize::CurrentStyle => context.style().get_font().clone_font_size().size(),
FontBaseSize::InheritedStyleButStripEmUnits | FontBaseSize::InheritedStyle => {
@ -109,13 +101,9 @@ impl FontRelativeLength {
}
/// Computes the font-relative length.
pub fn to_computed_value(&self, context: &Context, base_size: FontBaseSize) -> CSSPixelLength {
use std::f32;
pub fn to_computed_value(&self, context: &Context, base_size: FontBaseSize) -> computed::Length {
let (reference_size, length) = self.reference_font_size_and_length(context, base_size);
let pixel = (length * reference_size.to_f32_px())
.min(f32::MAX)
.max(f32::MIN);
CSSPixelLength::new(pixel)
reference_size * length
}
/// Return reference font size.
@ -129,7 +117,7 @@ impl FontRelativeLength {
&self,
context: &Context,
base_size: FontBaseSize,
) -> (Au, CSSFloat) {
) -> (computed::Length, CSSFloat) {
fn query_font_metrics(
context: &Context,
base_size: FontBaseSize,
@ -153,7 +141,7 @@ impl FontRelativeLength {
}
if base_size == FontBaseSize::InheritedStyleButStripEmUnits {
(Au(0), length)
(Zero::zero(), length)
} else {
(reference_font_size, length)
}
@ -175,7 +163,7 @@ impl FontRelativeLength {
// determine the x-height, a value of 0.5em must be
// assumed.
//
reference_font_size.scale_by(0.5)
reference_font_size * 0.5
});
(reference_size, length)
},
@ -210,7 +198,7 @@ impl FontRelativeLength {
if wm.is_vertical() && wm.is_upright() {
reference_font_size
} else {
reference_font_size.scale_by(0.5)
reference_font_size * 0.5
}
});
(reference_size, length)
@ -225,7 +213,7 @@ impl FontRelativeLength {
let reference_size = if context.is_root_element || context.in_media_query {
reference_font_size
} else {
context.device().root_font_size()
computed::Length::new(context.device().root_font_size().to_f32_px())
};
(reference_size, length)
},
@ -290,15 +278,14 @@ pub struct CharacterWidth(pub i32);
impl CharacterWidth {
/// Computes the given character width.
pub fn to_computed_value(&self, reference_font_size: Au) -> CSSPixelLength {
// This applies the *converting a character width to pixels* algorithm as specified
// in HTML5 § 14.5.4.
pub fn to_computed_value(&self, reference_font_size: computed::Length) -> computed::Length {
// This applies the *converting a character width to pixels* algorithm
// as specified in HTML5 § 14.5.4.
//
// TODO(pcwalton): Find these from the font.
let average_advance = reference_font_size.scale_by(0.5);
let average_advance = reference_font_size * 0.5;
let max_advance = reference_font_size;
let au = average_advance.scale_by(self.0 as CSSFloat - 1.0) + max_advance;
au.into()
average_advance * (self.0 as CSSFloat - 1.0) + max_advance
}
}

13
components/style/values/specified/text.rs
View file

@ -77,7 +77,6 @@ impl ToComputedValue for LineHeight {
#[inline]
fn to_computed_value(&self, context: &Context) -> Self::ComputedValue {
use crate::values::computed::Length as ComputedLength;
use crate::values::specified::length::FontBaseSize;
match *self {
GenericLineHeight::Normal => GenericLineHeight::Normal,
@ -97,16 +96,8 @@ impl ToComputedValue for LineHeight {
LengthPercentage::Calc(ref calc) => {
let computed_calc =
calc.to_computed_value_zoomed(context, FontBaseSize::CurrentStyle);
let font_relative_length =
FontRelativeLength::Em(computed_calc.percentage())
.to_computed_value(context, FontBaseSize::CurrentStyle)
.px();
let absolute_length = computed_calc.unclamped_length().px();
let pixel = computed_calc
.clamping_mode
.clamp(absolute_length + font_relative_length);
ComputedLength::new(pixel)
let base = context.style().get_font().clone_font_size().size();
computed_calc.percentage_relative_to(base)
},
};
GenericLineHeight::Length(result.into())