Implement parsing/serialization for border-image-* longhands

This commit is contained in:
Nazım Can Altınova 2016-10-30 22:35:52 +03:00
parent dbf43c9035
commit da27b61352
2 changed files with 728 additions and 0 deletions

View file

@ -64,3 +64,719 @@ ${helpers.single_keyword("-moz-float-edge", "content-box margin-box",
gecko_enum_prefix="StyleFloatEdge",
products="gecko",
animatable=False)}
// https://drafts.csswg.org/css-backgrounds-3/#border-image-source
<%helpers:longhand name="border-image-source" products="none" animatable="False">
use cssparser::ToCss;
use std::fmt;
use values::LocalToCss;
use values::NoViewportPercentage;
use values::specified::Image;
impl NoViewportPercentage for SpecifiedValue {}
pub mod computed_value {
use values::computed;
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
pub struct T(pub Option<computed::Image>);
}
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
pub struct SpecifiedValue(pub Option<Image>);
impl ToCss for computed_value::T {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match self.0 {
Some(ref image) => image.to_css(dest),
None => dest.write_str("none"),
}
}
}
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match self.0 {
Some(ref image) => image.to_css(dest),
None => dest.write_str("none"),
}
}
}
#[inline]
pub fn get_initial_value() -> computed_value::T {
computed_value::T(None)
}
impl ToComputedValue for SpecifiedValue {
type ComputedValue = computed_value::T;
#[inline]
fn to_computed_value(&self, context: &Context) -> computed_value::T {
match self.0 {
Some(ref image) => computed_value::T(Some(image.to_computed_value(context))),
None => computed_value::T(None),
}
}
#[inline]
fn from_computed_value(computed: &computed_value::T) -> Self {
match computed.0 {
Some(ref image) =>
SpecifiedValue(Some(ToComputedValue::from_computed_value(image))),
None => SpecifiedValue(None),
}
}
}
pub fn parse(context: &ParserContext, input: &mut Parser) -> Result<SpecifiedValue, ()> {
if input.try(|input| input.expect_ident_matching("none")).is_ok() {
return Ok(SpecifiedValue(None));
}
Ok(SpecifiedValue(Some(try!(Image::parse(context, input)))))
}
</%helpers:longhand>
<%helpers:longhand name="border-image-outset" products="none" animatable="False">
use cssparser::ToCss;
use std::fmt;
use values::LocalToCss;
use values::NoViewportPercentage;
use values::specified::{Length, Number};
impl NoViewportPercentage for SpecifiedValue {}
pub mod computed_value {
use values::computed::{Length, Number};
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
pub struct T(pub LengthOrNumber, pub LengthOrNumber,
pub LengthOrNumber, pub LengthOrNumber);
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
pub enum LengthOrNumber {
Length(Length),
Number(Number),
}
}
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
pub struct SpecifiedValue(pub Vec<LengthOrNumber>);
impl ToCss for computed_value::T {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
try!(self.0.to_css(dest));
try!(dest.write_str(" "));
try!(self.1.to_css(dest));
try!(dest.write_str(" "));
try!(self.2.to_css(dest));
try!(dest.write_str(" "));
self.3.to_css(dest)
}
}
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
try!(self.0[0].to_css(dest));
for value in self.0.iter().skip(1) {
try!(dest.write_str(" "));
try!(value.to_css(dest));
}
Ok(())
}
}
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
pub enum LengthOrNumber {
Length(Length),
Number(Number),
}
impl ToCss for computed_value::LengthOrNumber {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match *self {
computed_value::LengthOrNumber::Length(len) => len.to_css(dest),
computed_value::LengthOrNumber::Number(number) => number.to_css(dest),
}
}
}
impl ToCss for LengthOrNumber {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match *self {
LengthOrNumber::Length(len) => len.to_css(dest),
LengthOrNumber::Number(number) => number.to_css(dest),
}
}
}
impl ToComputedValue for LengthOrNumber {
type ComputedValue = computed_value::LengthOrNumber;
#[inline]
fn to_computed_value(&self, context: &Context) -> computed_value::LengthOrNumber {
match *self {
LengthOrNumber::Length(len) =>
computed_value::LengthOrNumber::Length(len.to_computed_value(context)),
LengthOrNumber::Number(number) =>
computed_value::LengthOrNumber::Number(number.to_computed_value(context)),
}
}
#[inline]
fn from_computed_value(computed: &computed_value::LengthOrNumber) -> Self {
match *computed {
computed_value::LengthOrNumber::Length(len) =>
LengthOrNumber::Length(ToComputedValue::from_computed_value(&len)),
computed_value::LengthOrNumber::Number(number) =>
LengthOrNumber::Number(ToComputedValue::from_computed_value(&number)),
}
}
}
#[inline]
pub fn get_initial_value() -> computed_value::T {
computed_value::T(computed_value::LengthOrNumber::Number(0.0),
computed_value::LengthOrNumber::Number(0.0),
computed_value::LengthOrNumber::Number(0.0),
computed_value::LengthOrNumber::Number(0.0))
}
impl ToComputedValue for SpecifiedValue {
type ComputedValue = computed_value::T;
#[inline]
fn to_computed_value(&self, context: &Context) -> computed_value::T {
let length = self.0.len();
match length {
4 => computed_value::T(self.0[0].to_computed_value(context),
self.0[1].to_computed_value(context),
self.0[2].to_computed_value(context),
self.0[3].to_computed_value(context)),
3 => computed_value::T(self.0[0].to_computed_value(context),
self.0[1].to_computed_value(context),
self.0[2].to_computed_value(context),
self.0[1].to_computed_value(context)),
2 => computed_value::T(self.0[0].to_computed_value(context),
self.0[1].to_computed_value(context),
self.0[0].to_computed_value(context),
self.0[1].to_computed_value(context)),
1 => computed_value::T(self.0[0].to_computed_value(context),
self.0[0].to_computed_value(context),
self.0[0].to_computed_value(context),
self.0[0].to_computed_value(context)),
_ => unreachable!(),
}
}
#[inline]
fn from_computed_value(computed: &computed_value::T) -> Self {
SpecifiedValue(vec![ToComputedValue::from_computed_value(&computed.0),
ToComputedValue::from_computed_value(&computed.1),
ToComputedValue::from_computed_value(&computed.2),
ToComputedValue::from_computed_value(&computed.3)])
}
}
impl Parse for LengthOrNumber {
fn parse(input: &mut Parser) -> Result<LengthOrNumber, ()> {
let length = input.try(|input| Length::parse(input));
if let Ok(len) = length {
return Ok(LengthOrNumber::Length(len));
}
let num = try!(Number::parse_non_negative(input));
Ok(LengthOrNumber::Number(num))
}
}
pub fn parse(_context: &ParserContext, input: &mut Parser) -> Result<SpecifiedValue, ()> {
let mut values = vec![];
for _ in 0..4 {
let value = input.try(|input| LengthOrNumber::parse(input));
match value {
Ok(val) => values.push(val),
Err(_) => break,
}
}
if values.len() > 0 {
Ok(SpecifiedValue(values))
} else {
Err(())
}
}
</%helpers:longhand>
// https://drafts.csswg.org/css-backgrounds-3/#border-image-repeat
<%helpers:longhand name="border-image-repeat" products="none" animatable="False">
use cssparser::ToCss;
use std::fmt;
use values::LocalToCss;
use values::NoViewportPercentage;
impl NoViewportPercentage for SpecifiedValue {}
pub mod computed_value {
use super::RepeatKeyword;
use values::computed;
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
pub struct T(pub RepeatKeyword, pub RepeatKeyword);
}
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
pub struct SpecifiedValue(pub RepeatKeyword,
pub Option<RepeatKeyword>);
define_css_keyword_enum!(RepeatKeyword:
"stretch" => Stretch,
"repeat" => Repeat,
"round" => Round,
"space" => Space);
impl ToCss for computed_value::T {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
try!(self.0.to_css(dest));
try!(dest.write_str(" "));
self.0.to_css(dest)
}
}
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
try!(self.0.to_css(dest));
if self.1.is_some() {
try!(dest.write_str(" "));
try!(self.0.to_css(dest));
}
Ok(())
}
}
#[inline]
pub fn get_initial_value() -> computed_value::T {
computed_value::T(RepeatKeyword::Stretch, RepeatKeyword::Stretch)
}
impl ToComputedValue for SpecifiedValue {
type ComputedValue = computed_value::T;
#[inline]
fn to_computed_value(&self, _context: &Context) -> computed_value::T {
computed_value::T(self.0, self.1.unwrap_or(self.0))
}
#[inline]
fn from_computed_value(computed: &computed_value::T) -> Self {
SpecifiedValue(computed.0, Some(computed.1))
}
}
pub fn parse(_context: &ParserContext, input: &mut Parser) -> Result<SpecifiedValue, ()> {
let first = try!(RepeatKeyword::parse(input));
let second = input.try(RepeatKeyword::parse).ok();
Ok(SpecifiedValue(first, second))
}
</%helpers:longhand>
// https://drafts.csswg.org/css-backgrounds-3/#border-image-width
<%helpers:longhand name="border-image-width" products="none" animatable="False">
use cssparser::ToCss;
use std::fmt;
use values::LocalToCss;
use values::HasViewportPercentage;
use values::specified::{LengthOrPercentage, Number};
impl HasViewportPercentage for SpecifiedValue {
fn has_viewport_percentage(&self) -> bool {
let mut viewport_percentage = false;
for value in self.0.clone() {
let vp = match value {
SingleSpecifiedValue::LengthOrPercentage(len) => len.has_viewport_percentage(),
_ => false,
};
viewport_percentage = vp || viewport_percentage;
}
viewport_percentage
}
}
pub mod computed_value {
use values::computed::{LengthOrPercentage, Number};
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
pub struct T(pub SingleComputedValue, pub SingleComputedValue,
pub SingleComputedValue, pub SingleComputedValue);
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
pub enum SingleComputedValue {
LengthOrPercentage(LengthOrPercentage),
Number(Number),
Auto,
}
}
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
pub struct SpecifiedValue(pub Vec<SingleSpecifiedValue>);
impl ToCss for computed_value::T {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
try!(self.0.to_css(dest));
try!(dest.write_str(" "));
try!(self.1.to_css(dest));
try!(dest.write_str(" "));
try!(self.2.to_css(dest));
try!(dest.write_str(" "));
self.3.to_css(dest)
}
}
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
try!(self.0[0].to_css(dest));
for value in self.0.iter().skip(1) {
try!(dest.write_str(" "));
try!(value.to_css(dest));
}
Ok(())
}
}
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
pub enum SingleSpecifiedValue {
LengthOrPercentage(LengthOrPercentage),
Number(Number),
Auto,
}
impl ToCss for computed_value::SingleComputedValue {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match *self {
computed_value::SingleComputedValue::LengthOrPercentage(len) => len.to_css(dest),
computed_value::SingleComputedValue::Number(number) => number.to_css(dest),
computed_value::SingleComputedValue::Auto => dest.write_str("auto"),
}
}
}
impl ToCss for SingleSpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match *self {
SingleSpecifiedValue::LengthOrPercentage(len) => len.to_css(dest),
SingleSpecifiedValue::Number(number) => number.to_css(dest),
SingleSpecifiedValue::Auto => dest.write_str("auto"),
}
}
}
impl ToComputedValue for SingleSpecifiedValue {
type ComputedValue = computed_value::SingleComputedValue;
#[inline]
fn to_computed_value(&self, context: &Context) -> computed_value::SingleComputedValue {
match *self {
SingleSpecifiedValue::LengthOrPercentage(len) => {
computed_value::SingleComputedValue::LengthOrPercentage(
len.to_computed_value(context))
},
SingleSpecifiedValue::Number(number) =>
computed_value::SingleComputedValue::Number(number.to_computed_value(context)),
SingleSpecifiedValue::Auto => computed_value::SingleComputedValue::Auto,
}
}
#[inline]
fn from_computed_value(computed: &computed_value::SingleComputedValue) -> Self {
match *computed {
computed_value::SingleComputedValue::LengthOrPercentage(len) => {
SingleSpecifiedValue::LengthOrPercentage(
ToComputedValue::from_computed_value(&len))
},
computed_value::SingleComputedValue::Number(number) =>
SingleSpecifiedValue::Number(ToComputedValue::from_computed_value(&number)),
computed_value::SingleComputedValue::Auto => SingleSpecifiedValue::Auto,
}
}
}
#[inline]
pub fn get_initial_value() -> computed_value::T {
computed_value::T(computed_value::SingleComputedValue::Number(1.0),
computed_value::SingleComputedValue::Number(1.0),
computed_value::SingleComputedValue::Number(1.0),
computed_value::SingleComputedValue::Number(1.0))
}
impl ToComputedValue for SpecifiedValue {
type ComputedValue = computed_value::T;
#[inline]
fn to_computed_value(&self, context: &Context) -> computed_value::T {
let length = self.0.len();
match length {
4 => computed_value::T(self.0[0].to_computed_value(context),
self.0[1].to_computed_value(context),
self.0[2].to_computed_value(context),
self.0[3].to_computed_value(context)),
3 => computed_value::T(self.0[0].to_computed_value(context),
self.0[1].to_computed_value(context),
self.0[2].to_computed_value(context),
self.0[1].to_computed_value(context)),
2 => computed_value::T(self.0[0].to_computed_value(context),
self.0[1].to_computed_value(context),
self.0[0].to_computed_value(context),
self.0[1].to_computed_value(context)),
1 => computed_value::T(self.0[0].to_computed_value(context),
self.0[0].to_computed_value(context),
self.0[0].to_computed_value(context),
self.0[0].to_computed_value(context)),
_ => unreachable!(),
}
}
#[inline]
fn from_computed_value(computed: &computed_value::T) -> Self {
SpecifiedValue(vec![ToComputedValue::from_computed_value(&computed.0),
ToComputedValue::from_computed_value(&computed.1),
ToComputedValue::from_computed_value(&computed.2),
ToComputedValue::from_computed_value(&computed.3)])
}
}
impl Parse for SingleSpecifiedValue {
fn parse(input: &mut Parser) -> Result<Self, ()> {
if input.try(|input| input.expect_ident_matching("auto")).is_ok() {
return Ok(SingleSpecifiedValue::Auto);
}
if let Ok(len) = input.try(|input| LengthOrPercentage::parse(input)) {
return Ok(SingleSpecifiedValue::LengthOrPercentage(len));
}
let num = try!(Number::parse_non_negative(input));
Ok(SingleSpecifiedValue::Number(num))
}
}
pub fn parse(_context: &ParserContext, input: &mut Parser) -> Result<SpecifiedValue, ()> {
let mut values = vec![];
for _ in 0..4 {
let value = input.try(|input| SingleSpecifiedValue::parse(input));
match value {
Ok(val) => values.push(val),
Err(_) => break,
}
}
if values.len() > 0 {
Ok(SpecifiedValue(values))
} else {
Err(())
}
}
</%helpers:longhand>
// https://drafts.csswg.org/css-backgrounds-3/#border-image-slice
<%helpers:longhand name="border-image-slice" products="none" animatable="False">
use cssparser::ToCss;
use std::fmt;
use values::LocalToCss;
use values::NoViewportPercentage;
use values::specified::{Number, Percentage};
impl NoViewportPercentage for SpecifiedValue {}
pub mod computed_value {
use values::computed::Number;
use values::specified::Percentage;
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
pub struct T {
pub corners: Vec<PercentageOrNumber>,
pub fill: bool,
}
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
pub enum PercentageOrNumber {
Percentage(Percentage),
Number(Number),
}
}
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
pub struct SpecifiedValue {
pub corners: Vec<PercentageOrNumber>,
pub fill: bool,
}
impl ToCss for computed_value::T {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
try!(self.corners[0].to_css(dest));
try!(dest.write_str(" "));
try!(self.corners[1].to_css(dest));
try!(dest.write_str(" "));
try!(self.corners[2].to_css(dest));
try!(dest.write_str(" "));
try!(self.corners[3].to_css(dest));
if self.fill {
try!(dest.write_str("fill"));
}
Ok(())
}
}
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
try!(self.corners[0].to_css(dest));
for value in self.corners.iter().skip(1) {
try!(dest.write_str(" "));
try!(value.to_css(dest));
}
if self.fill {
try!(dest.write_str("fill"));
}
Ok(())
}
}
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
pub enum PercentageOrNumber {
Percentage(Percentage),
Number(Number),
}
impl ToCss for computed_value::PercentageOrNumber {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match *self {
computed_value::PercentageOrNumber::Percentage(percentage) => percentage.to_css(dest),
computed_value::PercentageOrNumber::Number(number) => number.to_css(dest),
}
}
}
impl ToCss for PercentageOrNumber {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match *self {
PercentageOrNumber::Percentage(percentage) => percentage.to_css(dest),
PercentageOrNumber::Number(number) => number.to_css(dest),
}
}
}
impl ToComputedValue for PercentageOrNumber {
type ComputedValue = computed_value::PercentageOrNumber;
#[inline]
fn to_computed_value(&self, context: &Context) -> computed_value::PercentageOrNumber {
match *self {
PercentageOrNumber::Percentage(percentage) =>
computed_value::PercentageOrNumber::Percentage(percentage),
PercentageOrNumber::Number(number) =>
computed_value::PercentageOrNumber::Number(number.to_computed_value(context)),
}
}
#[inline]
fn from_computed_value(computed: &computed_value::PercentageOrNumber) -> Self {
match *computed {
computed_value::PercentageOrNumber::Percentage(percentage) =>
PercentageOrNumber::Percentage(percentage),
computed_value::PercentageOrNumber::Number(number) =>
PercentageOrNumber::Number(ToComputedValue::from_computed_value(&number)),
}
}
}
#[inline]
pub fn get_initial_value() -> computed_value::T {
computed_value::T {
corners: vec![computed_value::PercentageOrNumber::Percentage(Percentage(1.0)),
computed_value::PercentageOrNumber::Percentage(Percentage(1.0)),
computed_value::PercentageOrNumber::Percentage(Percentage(1.0)),
computed_value::PercentageOrNumber::Percentage(Percentage(1.0))],
fill: false,
}
}
impl ToComputedValue for SpecifiedValue {
type ComputedValue = computed_value::T;
#[inline]
fn to_computed_value(&self, context: &Context) -> computed_value::T {
let length = self.corners.len();
let corners = match length {
4 => vec![self.corners[0].to_computed_value(context),
self.corners[1].to_computed_value(context),
self.corners[2].to_computed_value(context),
self.corners[3].to_computed_value(context)],
3 => vec![self.corners[0].to_computed_value(context),
self.corners[1].to_computed_value(context),
self.corners[2].to_computed_value(context),
self.corners[1].to_computed_value(context)],
2 => vec![self.corners[0].to_computed_value(context),
self.corners[1].to_computed_value(context),
self.corners[0].to_computed_value(context),
self.corners[1].to_computed_value(context)],
1 => vec![self.corners[0].to_computed_value(context),
self.corners[0].to_computed_value(context),
self.corners[0].to_computed_value(context),
self.corners[0].to_computed_value(context)],
_ => unreachable!(),
};
computed_value::T {
corners: corners,
fill: self.fill,
}
}
#[inline]
fn from_computed_value(computed: &computed_value::T) -> Self {
SpecifiedValue {
corners: vec![ToComputedValue::from_computed_value(&computed.corners[0]),
ToComputedValue::from_computed_value(&computed.corners[1]),
ToComputedValue::from_computed_value(&computed.corners[2]),
ToComputedValue::from_computed_value(&computed.corners[3])],
fill: computed.fill,
}
}
}
impl Parse for PercentageOrNumber {
fn parse(input: &mut Parser) -> Result<Self, ()> {
if let Ok(per) = input.try(|input| Percentage::parse(input)) {
return Ok(PercentageOrNumber::Percentage(per));
}
let num = try!(Number::parse_non_negative(input));
Ok(PercentageOrNumber::Number(num))
}
}
pub fn parse(_context: &ParserContext, input: &mut Parser) -> Result<SpecifiedValue, ()> {
let mut fill = input.try(|input| input.expect_ident_matching("fill")).is_ok();
let mut values = vec![];
for _ in 0..4 {
let value = input.try(|input| PercentageOrNumber::parse(input));
match value {
Ok(val) => values.push(val),
Err(_) => break,
}
}
if fill == false {
fill = input.try(|input| input.expect_ident_matching("fill")).is_ok();
}
if values.len() > 0 {
Ok(SpecifiedValue {
corners: values,
fill: fill
})
} else {
Err(())
}
}
</%helpers:longhand>

View file

@ -713,6 +713,18 @@ impl ToCss for Percentage {
}
}
impl Parse for Percentage {
#[inline]
fn parse(input: &mut Parser) -> Result<Self, ()> {
let context = AllowedNumericType::All;
match try!(input.next()) {
Token::Percentage(ref value) if context.is_ok(value.unit_value) =>
Ok(Percentage(value.unit_value)),
_ => Err(())
}
}
}
#[derive(Clone, PartialEq, Copy, Debug)]
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
pub enum LengthOrPercentage {