Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-07-24 15:50:21 +01:00
Code Issues Projects Releases Packages Wiki Activity

Make font-feature-settings a subprop of font

Browse source
This commit is contained in:
Xidorn Quan 2017-05-12 14:53:57 +10:00
parent 29f5b226ac
commit 5b4f0686c7
5 changed files with 41 additions and 24 deletions
Download patch file Download diff file Expand all files Collapse all files

3
components/style/properties/data.py
View file

@ -18,7 +18,8 @@ SYSTEM_FONT_LONGHANDS = """font_family font_size font_style
font_variant_position font_weight font_variant_position font_weight
font_size_adjust font_variant_alternates font_size_adjust font_variant_alternates
font_variant_ligatures font_variant_east_asian font_variant_ligatures font_variant_east_asian
font_variant_numeric font_language_override""".split() font_variant_numeric font_language_override
font_feature_settings""".split()
def maybe_moz_logical_alias(product, side, prop): def maybe_moz_logical_alias(product, side, prop):

31
components/style/properties/longhand/font.mako.rs
View file

@ -22,7 +22,7 @@
impl ToCss for SpecifiedValue { impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match *self { match *self {
SpecifiedValue::Value(v) => v.to_css(dest), SpecifiedValue::Value(ref v) => v.to_css(dest),
SpecifiedValue::System(_) => Ok(()) SpecifiedValue::System(_) => Ok(())
} }
} }
@ -47,17 +47,17 @@
fn to_computed_value(&self, _context: &Context) -> computed_value::T { fn to_computed_value(&self, _context: &Context) -> computed_value::T {
match *self { match *self {
SpecifiedValue::Value(v) => v, SpecifiedValue::Value(ref v) => v.clone(),
SpecifiedValue::System(_) => { SpecifiedValue::System(_) => {
<%self:nongecko_unreachable> <%self:nongecko_unreachable>
_context.cached_system_font.as_ref().unwrap().${name} _context.cached_system_font.as_ref().unwrap().${name}.clone()
</%self:nongecko_unreachable> </%self:nongecko_unreachable>
} }
} }
} }
fn from_computed_value(other: &computed_value::T) -> Self { fn from_computed_value(other: &computed_value::T) -> Self {
SpecifiedValue::Value(*other) SpecifiedValue::Value(other.clone())
} }
} }
</%def> </%def>
@ -1777,17 +1777,24 @@ ${helpers.single_keyword_system("font-variant-position",
spec="https://drafts.csswg.org/css-fonts/#propdef-font-variant-position", spec="https://drafts.csswg.org/css-fonts/#propdef-font-variant-position",
animation_value_type="none")} animation_value_type="none")}
<%helpers:longhand name="font-feature-settings" products="gecko" animation_value_type="none" extra_prefixes="moz" <%helpers:longhand name="font-feature-settings" products="gecko" animation_value_type="none"
extra_prefixes="moz" boxed="True"
spec="https://drafts.csswg.org/css-fonts/#propdef-font-feature-settings"> spec="https://drafts.csswg.org/css-fonts/#propdef-font-feature-settings">
use properties::longhands::system_font::SystemFont;
use std::fmt; use std::fmt;
use style_traits::ToCss; use style_traits::ToCss;
use values::HasViewportPercentage; use values::HasViewportPercentage;
use values::computed::ComputedValueAsSpecified; use values::computed::ComputedValueAsSpecified;
pub use self::computed_value::T as SpecifiedValue;
impl ComputedValueAsSpecified for SpecifiedValue {} #[derive(Debug, Clone, PartialEq)]
pub enum SpecifiedValue {
Value(computed_value::T),
System(SystemFont)
}
no_viewport_percentage!(SpecifiedValue); no_viewport_percentage!(SpecifiedValue);
<%self:simple_system_boilerplate name="font_feature_settings"></%self:simple_system_boilerplate>
pub mod computed_value { pub mod computed_value {
use cssparser::Parser; use cssparser::Parser;
use parser::{Parse, ParserContext}; use parser::{Parse, ParserContext};
@ -1891,13 +1898,18 @@ ${helpers.single_keyword_system("font-variant-position",
computed_value::T::Normal computed_value::T::Normal
} }
#[inline]
pub fn get_initial_specified_value() -> SpecifiedValue {
SpecifiedValue::Value(computed_value::T::Normal)
}
/// normal | <feature-tag-value># /// normal | <feature-tag-value>#
pub fn parse(context: &ParserContext, input: &mut Parser) -> Result<SpecifiedValue, ()> { pub fn parse(context: &ParserContext, input: &mut Parser) -> Result<SpecifiedValue, ()> {
if input.try(|input| input.expect_ident_matching("normal")).is_ok() { if input.try(|input| input.expect_ident_matching("normal")).is_ok() {
Ok(computed_value::T::Normal) Ok(SpecifiedValue::Value(computed_value::T::Normal))
} else { } else {
input.parse_comma_separated(|i| computed_value::FeatureTagValue::parse(context, i)) input.parse_comma_separated(|i| computed_value::FeatureTagValue::parse(context, i))
.map(computed_value::T::Tag) .map(computed_value::T::Tag).map(SpecifiedValue::Value)
} }
} }
</%helpers:longhand> </%helpers:longhand>
@ -2390,6 +2402,7 @@ ${helpers.single_keyword("-moz-math-variant",
% endfor % endfor
font_language_override: longhands::font_language_override::computed_value font_language_override: longhands::font_language_override::computed_value
::T(system.languageOverride), ::T(system.languageOverride),
font_feature_settings: longhands::font_feature_settings::get_initial_value(),
system_font: *self, system_font: *self,
}; };
unsafe { bindings::Gecko_nsFont_Destroy(&mut system); } unsafe { bindings::Gecko_nsFont_Destroy(&mut system); }

5
components/style/properties/shorthand/font.mako.rs
View file

@ -15,7 +15,8 @@
${'font-variant-ligatures' if product == 'gecko' or data.testing else ''} ${'font-variant-ligatures' if product == 'gecko' or data.testing else ''}
${'font-variant-numeric' if product == 'gecko' or data.testing else ''} ${'font-variant-numeric' if product == 'gecko' or data.testing else ''}
${'font-variant-position' if product == 'gecko' or data.testing else ''} ${'font-variant-position' if product == 'gecko' or data.testing else ''}
${'font-language-override' if product == 'gecko' or data.testing else ''}" ${'font-language-override' if product == 'gecko' or data.testing else ''}
${'font-feature-settings' if product == 'gecko' or data.testing else ''}"
spec="https://drafts.csswg.org/css-fonts-3/#propdef-font"> spec="https://drafts.csswg.org/css-fonts-3/#propdef-font">
use properties::longhands::{font_family, font_style, font_weight, font_stretch}; use properties::longhands::{font_family, font_style, font_weight, font_stretch};
use properties::longhands::{font_size, line_height, font_variant_caps}; use properties::longhands::{font_size, line_height, font_variant_caps};
@ -25,7 +26,7 @@
gecko_sub_properties = "kerning language_override size_adjust \ gecko_sub_properties = "kerning language_override size_adjust \
variant_alternates variant_east_asian \ variant_alternates variant_east_asian \
variant_ligatures variant_numeric \ variant_ligatures variant_numeric \
variant_position".split() variant_position feature_settings".split()
%> %>
% if product == "gecko" or data.testing: % if product == "gecko" or data.testing:
% for prop in gecko_sub_properties: % for prop in gecko_sub_properties:

23
tests/unit/style/parsing/font.rs
View file

@ -4,6 +4,7 @@
use parsing::parse; use parsing::parse;
use style::properties::longhands::{font_feature_settings, font_weight}; use style::properties::longhands::{font_feature_settings, font_weight};
use style::properties::longhands::font_feature_settings::SpecifiedValue;
use style::properties::longhands::font_feature_settings::computed_value; use style::properties::longhands::font_feature_settings::computed_value;
use style::properties::longhands::font_feature_settings::computed_value::FeatureTagValue; use style::properties::longhands::font_feature_settings::computed_value::FeatureTagValue;
use style_traits::ToCss; use style_traits::ToCss;
@ -14,7 +15,7 @@ fn font_feature_settings_should_parse_properly() {
use std::io::Cursor; use std::io::Cursor;
let normal = parse_longhand!(font_feature_settings, "normal"); let normal = parse_longhand!(font_feature_settings, "normal");
let normal_computed = computed_value::T::Normal; let normal_computed = SpecifiedValue::Value(computed_value::T::Normal);
assert_eq!(normal, normal_computed); assert_eq!(normal, normal_computed);
let mut a_d_bytes = Cursor::new(b"abcd"); let mut a_d_bytes = Cursor::new(b"abcd");
@ -24,34 +25,34 @@ fn font_feature_settings_should_parse_properly() {
let efgh = e_h_bytes.read_u32::<BigEndian>().unwrap(); let efgh = e_h_bytes.read_u32::<BigEndian>().unwrap();
let on = parse_longhand!(font_feature_settings, "\"abcd\" on"); let on = parse_longhand!(font_feature_settings, "\"abcd\" on");
let on_computed = computed_value::T::Tag(vec![ let on_computed = SpecifiedValue::Value(computed_value::T::Tag(vec![
FeatureTagValue { tag: abcd, value: 1 } FeatureTagValue { tag: abcd, value: 1 }
]); ]));
assert_eq!(on, on_computed); assert_eq!(on, on_computed);
let off = parse_longhand!(font_feature_settings, "\"abcd\" off"); let off = parse_longhand!(font_feature_settings, "\"abcd\" off");
let off_computed = computed_value::T::Tag(vec![ let off_computed = SpecifiedValue::Value(computed_value::T::Tag(vec![
FeatureTagValue { tag: abcd, value: 0 } FeatureTagValue { tag: abcd, value: 0 }
]); ]));
assert_eq!(off, off_computed); assert_eq!(off, off_computed);
let no_value = parse_longhand!(font_feature_settings, "\"abcd\""); let no_value = parse_longhand!(font_feature_settings, "\"abcd\"");
let no_value_computed = computed_value::T::Tag(vec![ let no_value_computed = SpecifiedValue::Value(computed_value::T::Tag(vec![
FeatureTagValue { tag: abcd, value: 1 } FeatureTagValue { tag: abcd, value: 1 }
]); ]));
assert_eq!(no_value, no_value_computed); assert_eq!(no_value, no_value_computed);
let pos_integer = parse_longhand!(font_feature_settings, "\"abcd\" 100"); let pos_integer = parse_longhand!(font_feature_settings, "\"abcd\" 100");
let pos_integer_computed = computed_value::T::Tag(vec![ let pos_integer_computed = SpecifiedValue::Value(computed_value::T::Tag(vec![
FeatureTagValue { tag: abcd, value: 100 } FeatureTagValue { tag: abcd, value: 100 }
]); ]));
assert_eq!(pos_integer, pos_integer_computed); assert_eq!(pos_integer, pos_integer_computed);
let multiple = parse_longhand!(font_feature_settings, "\"abcd\" off, \"efgh\""); let multiple = parse_longhand!(font_feature_settings, "\"abcd\" off, \"efgh\"");
let multiple_computed = computed_value::T::Tag(vec![ let multiple_computed = SpecifiedValue::Value(computed_value::T::Tag(vec![
FeatureTagValue { tag: abcd, value: 0 }, FeatureTagValue { tag: abcd, value: 0 },
FeatureTagValue { tag: efgh, value: 1 } FeatureTagValue { tag: efgh, value: 1 }
]); ]));
assert_eq!(multiple, multiple_computed); assert_eq!(multiple, multiple_computed);
} }

3
tests/unit/style/properties/serialization.rs
View file

@ -653,7 +653,8 @@ mod shorthand_serialization {
font-kerning: auto; \ font-kerning: auto; \
font-variant-caps: normal; \ font-variant-caps: normal; \
font-variant-position: normal; \ font-variant-position: normal; \
font-language-override: normal;"; font-language-override: normal; \
font-feature-settings: normal;";
let block = parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap(); let block = parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();