From d1558a2025feae49d252e1e39a6bdec66332f7bf Mon Sep 17 00:00:00 2001 From: Simon Sapin Date: Fri, 14 Apr 2017 09:10:31 +0200 Subject: [PATCH] Add 'negative' descriptor of @counter-style --- components/style/counter_style.rs | 72 ++++++++++++++++++++++++++++--- components/style/gecko/rules.rs | 57 ++++++++++++++++++------ 2 files changed, 109 insertions(+), 20 deletions(-) diff --git a/components/style/counter_style.rs b/components/style/counter_style.rs index 19290f8ea3b..9d3551a4d52 100644 --- a/components/style/counter_style.rs +++ b/components/style/counter_style.rs @@ -6,7 +6,8 @@ //! //! [counter-style]: https://drafts.csswg.org/css-counter-styles/ -use cssparser::{AtRuleParser, DeclarationListParser, DeclarationParser, Parser}; +use cssparser::{AtRuleParser, DeclarationListParser, DeclarationParser, Parser, Token}; +use cssparser::{serialize_string, serialize_identifier}; #[cfg(feature = "gecko")] use gecko::rules::CounterStyleDescriptors; #[cfg(feature = "gecko")] use gecko_bindings::structs::nsCSSCounterDesc; use parser::{ParserContext, log_css_error, Parse}; @@ -56,7 +57,7 @@ impl<'a, 'b> AtRuleParser for CounterStyleRuleParser<'a, 'b> { macro_rules! counter_style_descriptors { ( - $( #[$doc: meta] $name: tt $ident: ident / $gecko_ident: ident: $ty: ty = $initial: expr, )+ + $( #[$doc: meta] $name: tt $ident: ident / $gecko_ident: ident: $ty: ty = $initial: expr; )+ ) => { /// An @counter-style rule #[derive(Debug)] @@ -82,7 +83,7 @@ macro_rules! counter_style_descriptors { #[cfg(feature = "gecko")] pub fn set_descriptors(&self, descriptors: &mut CounterStyleDescriptors) { $( - descriptors[nsCSSCounterDesc::$gecko_ident as usize].set_from(&self.$ident) + descriptors[nsCSSCounterDesc::$gecko_ident as usize].set_from(&self.$ident); )* } } @@ -126,11 +127,15 @@ macro_rules! counter_style_descriptors { } counter_style_descriptors! { - /// The algorithm for constructing a string representation of a counter value - "system" system / eCSSCounterDesc_System: System = System::Symbolic, + /// https://drafts.csswg.org/css-counter-styles/#counter-style-system + "system" system / eCSSCounterDesc_System: System = System::Symbolic; + + /// https://drafts.csswg.org/css-counter-styles/#counter-style-negative + "negative" negative / eCSSCounterDesc_Negative: Negative = + Negative(Symbol::String("-".to_owned()), None); } -/// Value of the 'system' descriptor +/// https://drafts.csswg.org/css-counter-styles/#counter-style-system #[derive(Debug)] pub enum System { /// 'cyclic' @@ -195,3 +200,58 @@ impl ToCss for System { } } } + +/// https://drafts.csswg.org/css-counter-styles/#typedef-symbol +#[derive(Debug)] +pub enum Symbol { + /// + String(String), + /// + Ident(String), + // Not implemented: + // /// + // Image(Image), +} + +impl Parse for Symbol { + fn parse(_context: &ParserContext, input: &mut Parser) -> Result { + match input.next() { + Ok(Token::QuotedString(s)) => Ok(Symbol::String(s.into_owned())), + Ok(Token::Ident(s)) => Ok(Symbol::Ident(s.into_owned())), + _ => Err(()) + } + } +} + +impl ToCss for Symbol { + fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { + match *self { + Symbol::String(ref s) => serialize_string(s, dest), + Symbol::Ident(ref s) => serialize_identifier(s, dest), + } + } +} + +/// https://drafts.csswg.org/css-counter-styles/#counter-style-negative +#[derive(Debug)] +pub struct Negative(pub Symbol, pub Option); + +impl Parse for Negative { + fn parse(context: &ParserContext, input: &mut Parser) -> Result { + Ok(Negative( + Symbol::parse(context, input)?, + input.try(|input| Symbol::parse(context, input)).ok(), + )) + } +} + +impl ToCss for Negative { + fn to_css(&self, dest: &mut W) -> fmt::Result where W: fmt::Write { + self.0.to_css(dest)?; + if let Some(ref symbol) = self.1 { + dest.write_char(' ')?; + symbol.to_css(dest)? + } + Ok(()) + } +} diff --git a/components/style/gecko/rules.rs b/components/style/gecko/rules.rs index 086600059bb..068696b1cdf 100644 --- a/components/style/gecko/rules.rs +++ b/components/style/gecko/rules.rs @@ -6,7 +6,7 @@ use computed_values::{font_style, font_weight, font_stretch}; use computed_values::font_family::FamilyName; -use counter_style::System; +use counter_style; use cssparser::UnicodeRange; use font_face::{FontFaceRuleData, Source}; use gecko_bindings::bindings; @@ -138,23 +138,52 @@ impl ToCssWithGuard for FontFaceRule { /// The type of nsCSSCounterStyleRule::mValues pub type CounterStyleDescriptors = [nsCSSValue; nsCSSCounterDesc::eCSSCounterDesc_COUNT as usize]; -impl ToNsCssValue for System { - fn convert(&self, v: &mut nsCSSValue) { +impl ToNsCssValue for counter_style::System { + fn convert(&self, nscssvalue: &mut nsCSSValue) { + use counter_style::System::*; match *self { - System::Cyclic => v.set_enum(structs::NS_STYLE_COUNTER_SYSTEM_CYCLIC as i32), - System::Numeric => v.set_enum(structs::NS_STYLE_COUNTER_SYSTEM_NUMERIC as i32), - System::Alphabetic => v.set_enum(structs::NS_STYLE_COUNTER_SYSTEM_ALPHABETIC as i32), - System::Symbolic => v.set_enum(structs::NS_STYLE_COUNTER_SYSTEM_SYMBOLIC as i32), - System::Additive => v.set_enum(structs::NS_STYLE_COUNTER_SYSTEM_ADDITIVE as i32), - System::Fixed { first_symbol_value: _ } => { - // FIXME: add bindings for nsCSSValue::SetPairValue or equivalent - unimplemented!() + Cyclic => nscssvalue.set_enum(structs::NS_STYLE_COUNTER_SYSTEM_CYCLIC as i32), + Numeric => nscssvalue.set_enum(structs::NS_STYLE_COUNTER_SYSTEM_NUMERIC as i32), + Alphabetic => nscssvalue.set_enum(structs::NS_STYLE_COUNTER_SYSTEM_ALPHABETIC as i32), + Symbolic => nscssvalue.set_enum(structs::NS_STYLE_COUNTER_SYSTEM_SYMBOLIC as i32), + Additive => nscssvalue.set_enum(structs::NS_STYLE_COUNTER_SYSTEM_ADDITIVE as i32), + Fixed { first_symbol_value } => { + let mut a = nsCSSValue::null(); + let mut b = nsCSSValue::null(); + a.set_enum(structs::NS_STYLE_COUNTER_SYSTEM_FIXED as i32); + b.set_integer(first_symbol_value.unwrap_or(1)); + //nscssvalue.set_pair(a, b); // FIXME: add bindings for nsCSSValue::SetPairValue } - System::Extends(ref _other) => { - // FIXME: add bindings for nsCSSValue::SetPairValue or equivalent - unimplemented!() + Extends(ref other) => { + let mut a = nsCSSValue::null(); + let mut b = nsCSSValue::null(); + a.set_enum(structs::NS_STYLE_COUNTER_SYSTEM_EXTENDS as i32); + b.set_string_from_atom(&other.0); + //nscssvalue.set_pair(a, b); // FIXME: add bindings for nsCSSValue::SetPairValue } } } } +impl ToNsCssValue for counter_style::Negative { + fn convert(&self, nscssvalue: &mut nsCSSValue) { + if let Some(ref second) = self.1 { + let mut a = nsCSSValue::null(); + let mut b = nsCSSValue::null(); + a.set_from(&self.0); + b.set_from(second); + //nscssvalue.set_pair(a, b); // FIXME: add bindings for nsCSSValue::SetPairValue + } else { + nscssvalue.set_from(&self.0) + } + } +} + +impl ToNsCssValue for counter_style::Symbol { + fn convert(&self, nscssvalue: &mut nsCSSValue) { + match *self { + counter_style::Symbol::String(ref s) => nscssvalue.set_string(s), + counter_style::Symbol::Ident(ref s) => nscssvalue.set_ident(s), + } + } +}