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

Use generics for border-image-slice property

Browse source
This commit is contained in:
Anthony Ramine 2017-05-23 10:56:03 +02:00
parent c8eb277ca5
commit 078d4ed40c
8 changed files with 77 additions and 157 deletions
Download patch file Download diff file Expand all files Collapse all files

11
components/layout/display_list_builder.rs
View file

@ -1429,8 +1429,7 @@ impl FragmentDisplayListBuilding for Fragment {
url.clone(),
UsePlaceholder::No);
if let Some(webrender_image) = webrender_image {
// The corners array is guaranteed to be len=4 by the css parser.
let corners = &border_style_struct.border_image_slice.corners;
let corners = &border_style_struct.border_image_slice.offsets;
state.add_display_item(DisplayItem::Border(box BorderDisplayItem {
base: base,
@ -1438,10 +1437,10 @@ impl FragmentDisplayListBuilding for Fragment {
details: BorderDetails::Image(ImageBorder {
image: webrender_image,
fill: border_style_struct.border_image_slice.fill,
slice: SideOffsets2D::new(corners[0].resolve(webrender_image.height),
corners[1].resolve(webrender_image.width),
corners[2].resolve(webrender_image.height),
corners[3].resolve(webrender_image.width)),
slice: SideOffsets2D::new(corners.top.resolve(webrender_image.height),
corners.right.resolve(webrender_image.width),
corners.bottom.resolve(webrender_image.height),
corners.left.resolve(webrender_image.width)),
// TODO(gw): Support border-image-outset
outset: SideOffsets2D::zero(),
repeat_horizontal: convert_repeat_mode(border_style_struct.border_image_repeat.0),

6
components/style/properties/gecko.mako.rs
View file

@ -1020,9 +1020,9 @@ fn static_assert() {
pub fn set_border_image_slice(&mut self, v: longhands::border_image_slice::computed_value::T) {
use gecko_bindings::structs::{NS_STYLE_BORDER_IMAGE_SLICE_NOFILL, NS_STYLE_BORDER_IMAGE_SLICE_FILL};
for (i, corner) in v.corners.iter().enumerate() {
corner.to_gecko_style_coord(&mut self.gecko.mBorderImageSlice.data_at_mut(i));
}
% for side in SIDES:
v.offsets.${side.ident}.to_gecko_style_coord(&mut self.gecko.mBorderImageSlice.data_at_mut(${side.index}));
% endfor
let fill = if v.fill {
NS_STYLE_BORDER_IMAGE_SLICE_FILL

150
components/style/properties/longhand/border.mako.rs
View file

@ -291,147 +291,9 @@ ${helpers.predefined_type("border-image-width", "BorderImageWidth",
animation_value_type="none",
boxed=True)}
<%helpers:longhand name="border-image-slice" boxed="True" animation_value_type="none"
spec="https://drafts.csswg.org/css-backgrounds/#border-image-slice">
use std::fmt;
use style_traits::ToCss;
use values::computed::NumberOrPercentage as ComputedNumberOrPercentage;
use values::specified::{NumberOrPercentage, Percentage};
no_viewport_percentage!(SpecifiedValue);
pub mod computed_value {
use values::computed::NumberOrPercentage;
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
pub struct T {
pub corners: [NumberOrPercentage; 4],
pub fill: bool,
}
}
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
pub struct SpecifiedValue {
pub corners: Vec<NumberOrPercentage>,
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(())
}
}
#[inline]
pub fn get_initial_value() -> computed_value::T {
computed_value::T {
corners: [ComputedNumberOrPercentage::Percentage(Percentage(1.0)),
ComputedNumberOrPercentage::Percentage(Percentage(1.0)),
ComputedNumberOrPercentage::Percentage(Percentage(1.0)),
ComputedNumberOrPercentage::Percentage(Percentage(1.0))],
fill: false,
}
}
#[inline]
pub fn get_initial_specified_value() -> SpecifiedValue {
SpecifiedValue {
corners: vec![NumberOrPercentage::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 => [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 => [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 => [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 => [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,
}
}
}
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| NumberOrPercentage::parse_non_negative(context, input));
match value {
Ok(val) => values.push(val),
Err(_) => break,
}
}
if !fill {
fill = input.try(|input| input.expect_ident_matching("fill")).is_ok();
}
if !values.is_empty() {
Ok(SpecifiedValue {
corners: values,
fill: fill
})
} else {
Err(())
}
}
</%helpers:longhand>
${helpers.predefined_type("border-image-slice", "BorderImageSlice",
initial_value="computed::NumberOrPercentage::Percentage(computed::Percentage(1.)).into()",
initial_specified_value="specified::NumberOrPercentage::Percentage(specified::Percentage(1.)).into()",
spec="https://drafts.csswg.org/css-backgrounds/#border-image-slice",
animation_value_type="none",
boxed=True)}

6
components/style/values/computed/border.rs
View file

@ -4,8 +4,9 @@
//! Computed types for CSS values related to borders.
use values::computed::Number;
use values::computed::{Number, NumberOrPercentage};
use values::computed::length::LengthOrPercentage;
use values::generics::border::BorderImageSlice as GenericBorderImageSlice;
use values::generics::border::BorderImageWidthSide as GenericBorderImageWidthSide;
use values::generics::rect::Rect;
@ -15,6 +16,9 @@ pub type BorderImageWidth = Rect<BorderImageWidthSide>;
/// A computed value for a single side of a `border-image-width` property.
pub type BorderImageWidthSide = GenericBorderImageWidthSide<LengthOrPercentage, Number>;
/// A computed value for the `border-image-slice` property.
pub type BorderImageSlice = GenericBorderImageSlice<NumberOrPercentage>;
impl BorderImageWidthSide {
/// Returns `1`.
#[inline]

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

@ -24,7 +24,7 @@ use super::specified;
pub use app_units::Au;
pub use cssparser::Color as CSSColor;
pub use self::border::{BorderImageWidth, BorderImageWidthSide};
pub use self::border::{BorderImageSlice, BorderImageWidth, BorderImageWidthSide};
pub use self::image::{Gradient, GradientItem, ImageLayer, LineDirection, Image, ImageRect};
pub use self::rect::LengthOrNumberRect;
pub use super::{Auto, Either, None_};

37
components/style/values/generics/border.rs
View file

@ -6,6 +6,7 @@
use std::fmt;
use style_traits::ToCss;
use values::generics::rect::Rect;
/// A generic value for a single side of a `border-image-width` property.
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
@ -19,6 +20,16 @@ pub enum BorderImageWidthSide<LengthOrPercentage, Number> {
Auto,
}
/// A generic value for the `border-image-slice` property.
#[derive(Clone, Copy, Debug, HasViewportPercentage, PartialEq, ToComputedValue)]
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
pub struct BorderImageSlice<NumberOrPercentage> {
/// The offsets.
pub offsets: Rect<NumberOrPercentage>,
/// Whether to fill the middle part.
pub fill: bool,
}
impl<L, N> ToCss for BorderImageWidthSide<L, N>
where L: ToCss, N: ToCss,
{
@ -32,3 +43,29 @@ impl<L, N> ToCss for BorderImageWidthSide<L, N>
}
}
}
impl<N> From<N> for BorderImageSlice<N>
where N: Clone,
{
#[inline]
fn from(value: N) -> Self {
Self {
offsets: value.into(),
fill: false,
}
}
}
impl<N> ToCss for BorderImageSlice<N>
where N: PartialEq + ToCss,
{
fn to_css<W>(&self, dest: &mut W) -> fmt::Result
where W: fmt::Write
{
self.offsets.to_css(dest)?;
if self.fill {
dest.write_str(" fill")?;
}
Ok(())
}
}

20
components/style/values/specified/border.rs
View file

@ -6,9 +6,10 @@
use cssparser::Parser;
use parser::{Parse, ParserContext};
use values::generics::border::BorderImageSlice as GenericBorderImageSlice;
use values::generics::border::BorderImageWidthSide as GenericBorderImageWidthSide;
use values::generics::rect::Rect;
use values::specified::Number;
use values::specified::{Number, NumberOrPercentage};
use values::specified::length::LengthOrPercentage;
/// A specified value for the `border-image-width` property.
@ -17,6 +18,9 @@ pub type BorderImageWidth = Rect<BorderImageWidthSide>;
/// A specified value for a single side of a `border-image-width` property.
pub type BorderImageWidthSide = GenericBorderImageWidthSide<LengthOrPercentage, Number>;
/// A specified value for the `border-image-slice` property.
pub type BorderImageSlice = GenericBorderImageSlice<NumberOrPercentage>;
impl BorderImageWidthSide {
/// Returns `1`.
#[inline]
@ -39,3 +43,17 @@ impl Parse for BorderImageWidthSide {
Ok(GenericBorderImageWidthSide::Number(num))
}
}
impl Parse for BorderImageSlice {
fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ()> {
let mut fill = input.try(|i| i.expect_ident_matching("fill")).is_ok();
let offsets = Rect::parse_with(context, input, NumberOrPercentage::parse_non_negative)?;
if !fill {
fill = input.try(|i| i.expect_ident_matching("fill")).is_ok();
}
Ok(GenericBorderImageSlice {
offsets: offsets,
fill: fill,
})
}
}

2
components/style/values/specified/mod.rs
View file

@ -31,7 +31,7 @@ use values::specified::calc::CalcNode;
#[cfg(feature = "gecko")]
pub use self::align::{AlignItems, AlignJustifyContent, AlignJustifySelf, JustifyItems};
pub use self::rect::LengthOrNumberRect;
pub use self::border::{BorderImageWidth, BorderImageWidthSide};
pub use self::border::{BorderImageSlice, BorderImageWidth, BorderImageWidthSide};
pub use self::color::Color;
pub use super::generics::grid::GridLine;
pub use self::image::{ColorStop, EndingShape as GradientEndingShape, Gradient};