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

style: Rename LengthOrPercentage to LengthPercentage.

Browse source 
It does not represent `<length> | <percentage>`, but `<length-percentage>`, so
`LengthOrPercentage` is not the right name.

This patch is totally autogenerated using:

rg 'LengthOrPercentage' servo | cut -d : -f 1 | sort | uniq > files
for file in $(cat files); do sed -i "s#LengthOrPercentage#LengthPercentage#g" $file; done

Differential Revision: https://phabricator.services.mozilla.com/D15812
This commit is contained in:
Emilio Cobos Álvarez 2019-01-07 12:20:30 +01:00
parent 4a31509215
commit daf1f02feb
61 changed files with 709 additions and 702 deletions
Download patch file Download diff file Expand all files Collapse all files

2
components/style/attr.rs
View file

@ -543,7 +543,7 @@ pub fn parse_legacy_color(mut input: &str) -> Result<RGBA, ()> {
/// Parses a [dimension value][dim]. If unparseable, `Auto` is returned.
///
/// [dim]: https://html.spec.whatwg.org/multipage/#rules-for-parsing-dimension-values
// TODO: this function can be rewritten to return Result<LengthOrPercentage, _>
// TODO: this function can be rewritten to return Result<LengthPercentage, _>
pub fn parse_length(mut value: &str) -> LengthOrPercentageOrAuto {
// Steps 1 & 2 are not relevant

84
components/style/gecko/conversions.rs
View file

@ -21,8 +21,8 @@ use crate::values::computed::image::LineDirection;
use crate::values::computed::transform::Matrix3D;
use crate::values::computed::url::ComputedImageUrl;
use crate::values::computed::{Angle, Gradient, Image};
use crate::values::computed::{Integer, LengthOrPercentage};
use crate::values::computed::{LengthOrPercentageOrAuto, NonNegativeLengthOrPercentageOrAuto};
use crate::values::computed::{Integer, LengthPercentage};
use crate::values::computed::{LengthPercentageOrAuto, NonNegativeLengthPercentageOrAuto};
use crate::values::computed::{Percentage, TextAlign};
use crate::values::generics::box_::VerticalAlign;
use crate::values::generics::grid::{TrackListValue, TrackSize};
@ -33,8 +33,8 @@ use app_units::Au;
use std::f32::consts::PI;
use style_traits::values::specified::AllowedNumericType;
impl From<LengthOrPercentage> for nsStyleCoord_CalcValue {
fn from(other: LengthOrPercentage) -> nsStyleCoord_CalcValue {
impl From<LengthPercentage> for nsStyleCoord_CalcValue {
fn from(other: LengthPercentage) -> nsStyleCoord_CalcValue {
let has_percentage = other.percentage.is_some();
nsStyleCoord_CalcValue {
mLength: other.unclamped_length().to_i32_au(),
@ -44,8 +44,8 @@ impl From<LengthOrPercentage> for nsStyleCoord_CalcValue {
}
}
impl From<nsStyleCoord_CalcValue> for LengthOrPercentage {
fn from(other: nsStyleCoord_CalcValue) -> LengthOrPercentage {
impl From<nsStyleCoord_CalcValue> for LengthPercentage {
fn from(other: nsStyleCoord_CalcValue) -> LengthPercentage {
let percentage = if other.mHasPercent {
Some(Percentage(other.mPercent))
} else {
@ -60,28 +60,28 @@ impl From<nsStyleCoord_CalcValue> for LengthOrPercentage {
}
}
impl LengthOrPercentageOrAuto {
impl LengthPercentageOrAuto {
/// Convert this value in an appropriate `nsStyleCoord::CalcValue`.
pub fn to_calc_value(&self) -> Option<nsStyleCoord_CalcValue> {
match *self {
LengthOrPercentageOrAuto::LengthOrPercentage(len) => Some(From::from(len)),
LengthOrPercentageOrAuto::Auto => None,
LengthPercentageOrAuto::LengthPercentage(len) => Some(From::from(len)),
LengthPercentageOrAuto::Auto => None,
}
}
}
impl From<nsStyleCoord_CalcValue> for LengthOrPercentageOrAuto {
fn from(other: nsStyleCoord_CalcValue) -> LengthOrPercentageOrAuto {
LengthOrPercentageOrAuto::LengthOrPercentage(LengthOrPercentage::from(other))
impl From<nsStyleCoord_CalcValue> for LengthPercentageOrAuto {
fn from(other: nsStyleCoord_CalcValue) -> LengthPercentageOrAuto {
LengthPercentageOrAuto::LengthPercentage(LengthPercentage::from(other))
}
}
// FIXME(emilio): A lot of these impl From should probably become explicit or
// disappear as we move more stuff to cbindgen.
impl From<nsStyleCoord_CalcValue> for NonNegativeLengthOrPercentageOrAuto {
impl From<nsStyleCoord_CalcValue> for NonNegativeLengthPercentageOrAuto {
fn from(other: nsStyleCoord_CalcValue) -> Self {
NonNegative(
LengthOrPercentageOrAuto::LengthOrPercentage(LengthOrPercentage::with_clamping_mode(
LengthPercentageOrAuto::LengthPercentage(LengthPercentage::with_clamping_mode(
Au(other.mLength).into(),
if other.mHasPercent {
Some(Percentage(other.mPercent))
@ -101,7 +101,7 @@ impl From<Angle> for CoordDataValue {
}
}
fn line_direction(horizontal: LengthOrPercentage, vertical: LengthOrPercentage) -> LineDirection {
fn line_direction(horizontal: LengthPercentage, vertical: LengthPercentage) -> LineDirection {
use crate::values::computed::position::Position;
use crate::values::specified::position::{X, Y};
@ -467,8 +467,8 @@ impl nsStyleImage {
.as_ref()
.unwrap();
let angle = Angle::from_gecko_style_coord(&gecko_gradient.mAngle);
let horizontal_style = LengthOrPercentage::from_gecko_style_coord(&gecko_gradient.mBgPosX);
let vertical_style = LengthOrPercentage::from_gecko_style_coord(&gecko_gradient.mBgPosY);
let horizontal_style = LengthPercentage::from_gecko_style_coord(&gecko_gradient.mBgPosX);
let vertical_style = LengthPercentage::from_gecko_style_coord(&gecko_gradient.mBgPosY);
let kind = match gecko_gradient.mShape as u32 {
structs::NS_STYLE_GRADIENT_SHAPE_LINEAR => {
@ -529,20 +529,20 @@ impl nsStyleImage {
structs::NS_STYLE_GRADIENT_SHAPE_ELLIPTICAL => {
let length_percentage_keyword = match gecko_gradient.mSize as u32 {
structs::NS_STYLE_GRADIENT_SIZE_EXPLICIT_SIZE => match (
LengthOrPercentage::from_gecko_style_coord(
LengthPercentage::from_gecko_style_coord(
&gecko_gradient.mRadiusX,
),
LengthOrPercentage::from_gecko_style_coord(
LengthPercentage::from_gecko_style_coord(
&gecko_gradient.mRadiusY,
),
) {
(Some(x), Some(y)) => Ellipse::Radii(x, y),
_ => {
debug_assert!(false,
"mRadiusX, mRadiusY could not convert to LengthOrPercentage");
"mRadiusX, mRadiusY could not convert to LengthPercentage");
Ellipse::Radii(
LengthOrPercentage::zero(),
LengthOrPercentage::zero(),
LengthPercentage::zero(),
LengthPercentage::zero(),
)
},
},
@ -561,11 +561,11 @@ impl nsStyleImage {
_ => {
debug_assert!(
false,
"mRadiusX, mRadiusY could not convert to LengthOrPercentage"
"mRadiusX, mRadiusY could not convert to LengthPercentage"
);
Position {
horizontal: LengthOrPercentage::zero(),
vertical: LengthOrPercentage::zero(),
horizontal: LengthPercentage::zero(),
vertical: LengthPercentage::zero(),
}
},
};
@ -580,13 +580,13 @@ impl nsStyleImage {
.map(|ref stop| {
if stop.mIsInterpolationHint {
GradientItem::InterpolationHint(
LengthOrPercentage::from_gecko_style_coord(&stop.mLocation)
.expect("mLocation could not convert to LengthOrPercentage"),
LengthPercentage::from_gecko_style_coord(&stop.mLocation)
.expect("mLocation could not convert to LengthPercentage"),
)
} else {
GradientItem::ColorStop(ColorStop {
color: stop.mColor.into(),
position: LengthOrPercentage::from_gecko_style_coord(&stop.mLocation),
position: LengthPercentage::from_gecko_style_coord(&stop.mLocation),
})
}
})
@ -625,7 +625,7 @@ pub mod basic_shape {
BasicShape, ClippingShape, FloatAreaShape, ShapeRadius,
};
use crate::values::computed::border::{BorderCornerRadius, BorderRadius};
use crate::values::computed::length::LengthOrPercentage;
use crate::values::computed::length::LengthPercentage;
use crate::values::computed::motion::OffsetPath;
use crate::values::computed::position;
use crate::values::computed::url::ComputedUrl;
@ -742,10 +742,10 @@ pub mod basic_shape {
fn from(other: &'a StyleBasicShape) -> Self {
match other.mType {
StyleBasicShapeType::Inset => {
let t = LengthOrPercentage::from_gecko_style_coord(&other.mCoordinates[0]);
let r = LengthOrPercentage::from_gecko_style_coord(&other.mCoordinates[1]);
let b = LengthOrPercentage::from_gecko_style_coord(&other.mCoordinates[2]);
let l = LengthOrPercentage::from_gecko_style_coord(&other.mCoordinates[3]);
let t = LengthPercentage::from_gecko_style_coord(&other.mCoordinates[0]);
let r = LengthPercentage::from_gecko_style_coord(&other.mCoordinates[1]);
let b = LengthPercentage::from_gecko_style_coord(&other.mCoordinates[2]);
let l = LengthPercentage::from_gecko_style_coord(&other.mCoordinates[3]);
let round: BorderRadius = (&other.mRadius).into();
let round = if round.all_zero() { None } else { Some(round) };
let rect = Rect::new(
@ -771,12 +771,12 @@ pub mod basic_shape {
let x = 2 * i;
let y = x + 1;
coords.push(PolygonCoord(
LengthOrPercentage::from_gecko_style_coord(&other.mCoordinates[x])
LengthPercentage::from_gecko_style_coord(&other.mCoordinates[x])
.expect(
"polygon() coordinate should be a length, percentage, \
or calc value",
),
LengthOrPercentage::from_gecko_style_coord(&other.mCoordinates[y])
LengthPercentage::from_gecko_style_coord(&other.mCoordinates[y])
.expect(
"polygon() coordinate should be a length, percentage, \
or calc value",
@ -797,12 +797,12 @@ pub mod basic_shape {
let get_corner = |index| {
BorderCornerRadius::new(
NonNegative(
LengthOrPercentage::from_gecko_style_coord(&other.data_at(index)).expect(
LengthPercentage::from_gecko_style_coord(&other.data_at(index)).expect(
"<border-radius> should be a length, percentage, or calc value",
),
),
NonNegative(
LengthOrPercentage::from_gecko_style_coord(&other.data_at(index + 1))
LengthPercentage::from_gecko_style_coord(&other.data_at(index + 1))
.expect(
"<border-radius> should be a length, percentage, or calc value",
),
@ -958,11 +958,11 @@ impl From<Origin> for SheetType {
}
}
impl TrackSize<LengthOrPercentage> {
impl TrackSize<LengthPercentage> {
/// Return TrackSize from given two nsStyleCoord
pub fn from_gecko_style_coords<T: CoordData>(gecko_min: &T, gecko_max: &T) -> Self {
use crate::gecko_bindings::structs::root::nsStyleUnit;
use crate::values::computed::length::LengthOrPercentage;
use crate::values::computed::length::LengthPercentage;
use crate::values::generics::grid::{TrackBreadth, TrackSize};
if gecko_min.unit() == nsStyleUnit::eStyleUnit_None {
@ -972,8 +972,8 @@ impl TrackSize<LengthOrPercentage> {
gecko_max.unit() == nsStyleUnit::eStyleUnit_Calc
);
return TrackSize::FitContent(
LengthOrPercentage::from_gecko_style_coord(gecko_max)
.expect("gecko_max could not convert to LengthOrPercentage"),
LengthPercentage::from_gecko_style_coord(gecko_max)
.expect("gecko_max could not convert to LengthPercentage"),
);
}
@ -1013,7 +1013,7 @@ impl TrackSize<LengthOrPercentage> {
}
}
impl TrackListValue<LengthOrPercentage, Integer> {
impl TrackListValue<LengthPercentage, Integer> {
/// Return TrackSize from given two nsStyleCoord
pub fn from_gecko_style_coords<T: CoordData>(gecko_min: &T, gecko_max: &T) -> Self {
TrackListValue::TrackSize(TrackSize::from_gecko_style_coords(gecko_min, gecko_max))

50
components/style/gecko/values.rs
View file

@ -13,9 +13,9 @@ use crate::gecko_bindings::sugar::ns_style_coord::{CoordData, CoordDataMut, Coor
use crate::media_queries::Device;
use crate::values::computed::basic_shape::ShapeRadius as ComputedShapeRadius;
use crate::values::computed::FlexBasis as ComputedFlexBasis;
use crate::values::computed::{Angle, ExtremumLength, Length, LengthOrPercentage};
use crate::values::computed::{LengthOrPercentageOrAuto, Percentage};
use crate::values::computed::{LengthOrPercentageOrNone, Number, NumberOrPercentage};
use crate::values::computed::{Angle, ExtremumLength, Length, LengthPercentage};
use crate::values::computed::{LengthPercentageOrAuto, Percentage};
use crate::values::computed::{LengthPercentageOrNone, Number, NumberOrPercentage};
use crate::values::computed::{MaxLength as ComputedMaxLength, MozLength as ComputedMozLength};
use crate::values::generics::basic_shape::ShapeRadius;
use crate::values::generics::box_::Perspective;
@ -146,7 +146,7 @@ impl GeckoStyleCoordConvertible for NumberOrPercentage {
}
}
impl GeckoStyleCoordConvertible for LengthOrPercentage {
impl GeckoStyleCoordConvertible for LengthPercentage {
fn to_gecko_style_coord<T: CoordDataMut>(&self, coord: &mut T) {
if self.was_calc {
return coord.set_value(CoordDataValue::Calc((*self).into()))
@ -160,8 +160,8 @@ impl GeckoStyleCoordConvertible for LengthOrPercentage {
fn from_gecko_style_coord<T: CoordData>(coord: &T) -> Option<Self> {
match coord.as_value() {
CoordDataValue::Coord(coord) => Some(LengthOrPercentage::new(Au(coord).into(), None)),
CoordDataValue::Percent(p) => Some(LengthOrPercentage::new(Au(0).into(), Some(Percentage(p)))),
CoordDataValue::Coord(coord) => Some(LengthPercentage::new(Au(coord).into(), None)),
CoordDataValue::Percent(p) => Some(LengthPercentage::new(Au(0).into(), Some(Percentage(p)))),
CoordDataValue::Calc(calc) => Some(calc.into()),
_ => None,
}
@ -181,34 +181,34 @@ impl GeckoStyleCoordConvertible for Length {
}
}
impl GeckoStyleCoordConvertible for LengthOrPercentageOrAuto {
impl GeckoStyleCoordConvertible for LengthPercentageOrAuto {
fn to_gecko_style_coord<T: CoordDataMut>(&self, coord: &mut T) {
match *self {
LengthOrPercentageOrAuto::Auto => coord.set_value(CoordDataValue::Auto),
LengthOrPercentageOrAuto::LengthOrPercentage(ref lop) => lop.to_gecko_style_coord(coord),
LengthPercentageOrAuto::Auto => coord.set_value(CoordDataValue::Auto),
LengthPercentageOrAuto::LengthPercentage(ref lop) => lop.to_gecko_style_coord(coord),
}
}
fn from_gecko_style_coord<T: CoordData>(coord: &T) -> Option<Self> {
match coord.as_value() {
CoordDataValue::Auto => Some(LengthOrPercentageOrAuto::Auto),
_ => LengthOrPercentage::from_gecko_style_coord(coord).map(LengthOrPercentageOrAuto::LengthOrPercentage),
CoordDataValue::Auto => Some(LengthPercentageOrAuto::Auto),
_ => LengthPercentage::from_gecko_style_coord(coord).map(LengthPercentageOrAuto::LengthPercentage),
}
}
}
impl GeckoStyleCoordConvertible for LengthOrPercentageOrNone {
impl GeckoStyleCoordConvertible for LengthPercentageOrNone {
fn to_gecko_style_coord<T: CoordDataMut>(&self, coord: &mut T) {
match *self {
LengthOrPercentageOrNone::None => coord.set_value(CoordDataValue::None),
LengthOrPercentageOrNone::LengthOrPercentage(ref lop) => lop.to_gecko_style_coord(coord),
LengthPercentageOrNone::None => coord.set_value(CoordDataValue::None),
LengthPercentageOrNone::LengthPercentage(ref lop) => lop.to_gecko_style_coord(coord),
}
}
fn from_gecko_style_coord<T: CoordData>(coord: &T) -> Option<Self> {
match coord.as_value() {
CoordDataValue::None => Some(LengthOrPercentageOrNone::None),
_ => LengthOrPercentage::from_gecko_style_coord(coord).map(LengthOrPercentageOrNone::LengthOrPercentage),
CoordDataValue::None => Some(LengthPercentageOrNone::None),
_ => LengthPercentage::from_gecko_style_coord(coord).map(LengthPercentageOrNone::LengthPercentage),
}
}
}
@ -363,14 +363,14 @@ impl GeckoStyleCoordConvertible for ExtremumLength {
impl GeckoStyleCoordConvertible for ComputedMozLength {
fn to_gecko_style_coord<T: CoordDataMut>(&self, coord: &mut T) {
match *self {
MozLength::LengthOrPercentageOrAuto(ref lopoa) => lopoa.to_gecko_style_coord(coord),
MozLength::LengthPercentageOrAuto(ref lopoa) => lopoa.to_gecko_style_coord(coord),
MozLength::ExtremumLength(ref e) => e.to_gecko_style_coord(coord),
}
}
fn from_gecko_style_coord<T: CoordData>(coord: &T) -> Option<Self> {
LengthOrPercentageOrAuto::from_gecko_style_coord(coord)
.map(MozLength::LengthOrPercentageOrAuto)
LengthPercentageOrAuto::from_gecko_style_coord(coord)
.map(MozLength::LengthPercentageOrAuto)
.or_else(|| {
ExtremumLength::from_gecko_style_coord(coord).map(MozLength::ExtremumLength)
})
@ -380,21 +380,21 @@ impl GeckoStyleCoordConvertible for ComputedMozLength {
impl GeckoStyleCoordConvertible for ComputedMaxLength {
fn to_gecko_style_coord<T: CoordDataMut>(&self, coord: &mut T) {
match *self {
MaxLength::LengthOrPercentageOrNone(ref lopon) => lopon.to_gecko_style_coord(coord),
MaxLength::LengthPercentageOrNone(ref lopon) => lopon.to_gecko_style_coord(coord),
MaxLength::ExtremumLength(ref e) => e.to_gecko_style_coord(coord),
}
}
fn from_gecko_style_coord<T: CoordData>(coord: &T) -> Option<Self> {
LengthOrPercentageOrNone::from_gecko_style_coord(coord)
.map(MaxLength::LengthOrPercentageOrNone)
LengthPercentageOrNone::from_gecko_style_coord(coord)
.map(MaxLength::LengthPercentageOrNone)
.or_else(|| {
ExtremumLength::from_gecko_style_coord(coord).map(MaxLength::ExtremumLength)
})
}
}
impl GeckoStyleCoordConvertible for ScrollSnapPoint<LengthOrPercentage> {
impl GeckoStyleCoordConvertible for ScrollSnapPoint<LengthPercentage> {
fn to_gecko_style_coord<T: CoordDataMut>(&self, coord: &mut T) {
match self.repeated() {
None => coord.set_value(CoordDataValue::None),
@ -409,8 +409,8 @@ impl GeckoStyleCoordConvertible for ScrollSnapPoint<LengthOrPercentage> {
Some(match coord.unit() {
nsStyleUnit::eStyleUnit_None => ScrollSnapPoint::None,
_ => ScrollSnapPoint::Repeat(
LengthOrPercentage::from_gecko_style_coord(coord)
.expect("coord could not convert to LengthOrPercentage"),
LengthPercentage::from_gecko_style_coord(coord)
.expect("coord could not convert to LengthPercentage"),
),
})
}

14
components/style/gecko_bindings/sugar/ns_css_value.rs
View file

@ -9,7 +9,7 @@ use crate::gecko_bindings::structs;
use crate::gecko_bindings::structs::{nsCSSUnit, nsCSSValue};
use crate::gecko_bindings::structs::{nsCSSValueList, nsCSSValue_Array};
use crate::gecko_string_cache::Atom;
use crate::values::computed::{Angle, Length, LengthOrPercentage, Percentage};
use crate::values::computed::{Angle, Length, LengthPercentage, Percentage};
use std::marker::PhantomData;
use std::mem;
use std::ops::{Index, IndexMut};
@ -67,8 +67,8 @@ impl nsCSSValue {
&*array
}
/// Sets LengthOrPercentage value to this nsCSSValue.
pub unsafe fn set_lop(&mut self, lop: LengthOrPercentage) {
/// Sets LengthPercentage value to this nsCSSValue.
pub unsafe fn set_lop(&mut self, lop: LengthPercentage) {
if lop.was_calc {
return bindings::Gecko_CSSValue_SetCalc(self, lop.into())
}
@ -89,16 +89,16 @@ impl nsCSSValue {
bindings::Gecko_CSSValue_SetPercentage(self, unit_value)
}
/// Returns LengthOrPercentage value.
pub unsafe fn get_lop(&self) -> LengthOrPercentage {
/// Returns LengthPercentage value.
pub unsafe fn get_lop(&self) -> LengthPercentage {
match self.mUnit {
nsCSSUnit::eCSSUnit_Pixel => {
LengthOrPercentage::new(
LengthPercentage::new(
Length::new(bindings::Gecko_CSSValue_GetNumber(self)),
None,
)
},
nsCSSUnit::eCSSUnit_Percent => LengthOrPercentage::new_percent(Percentage(
nsCSSUnit::eCSSUnit_Percent => LengthPercentage::new_percent(Percentage(
bindings::Gecko_CSSValue_GetPercentage(self),
)),
nsCSSUnit::eCSSUnit_Calc => {

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

@ -510,7 +510,7 @@ def set_gecko_property(ffi_name, expr):
// set on mContextFlags, and the length field is set to the initial value.
pub fn set_${ident}(&mut self, v: longhands::${ident}::computed_value::T) {
use crate::values::generics::svg::{SVGLength, SvgLengthOrPercentageOrNumber};
use crate::values::generics::svg::{SVGLength, SvgLengthPercentageOrNumber};
use crate::gecko_bindings::structs::nsStyleSVG_${ident.upper()}_CONTEXT as CONTEXT_VALUE;
let length = match v {
SVGLength::Length(length) => {
@ -526,9 +526,9 @@ def set_gecko_property(ffi_name, expr):
}
};
match length {
SvgLengthOrPercentageOrNumber::LengthOrPercentage(lop) =>
SvgLengthPercentageOrNumber::LengthPercentage(lop) =>
self.gecko.${gecko_ffi_name}.set(lop),
SvgLengthOrPercentageOrNumber::Number(num) =>
SvgLengthPercentageOrNumber::Number(num) =>
self.gecko.${gecko_ffi_name}.set_value(CoordDataValue::Factor(num.into())),
}
}
@ -546,28 +546,28 @@ def set_gecko_property(ffi_name, expr):
}
pub fn clone_${ident}(&self) -> longhands::${ident}::computed_value::T {
use crate::values::generics::svg::{SVGLength, SvgLengthOrPercentageOrNumber};
use crate::values::computed::LengthOrPercentage;
use crate::values::generics::svg::{SVGLength, SvgLengthPercentageOrNumber};
use crate::values::computed::LengthPercentage;
use crate::gecko_bindings::structs::nsStyleSVG_${ident.upper()}_CONTEXT as CONTEXT_VALUE;
if (self.gecko.mContextFlags & CONTEXT_VALUE) != 0 {
return SVGLength::ContextValue;
}
let length = match self.gecko.${gecko_ffi_name}.as_value() {
CoordDataValue::Factor(number) => {
SvgLengthOrPercentageOrNumber::Number(number)
SvgLengthPercentageOrNumber::Number(number)
},
CoordDataValue::Coord(coord) => {
SvgLengthOrPercentageOrNumber::LengthOrPercentage(
LengthOrPercentage::new(Au(coord).into(), None)
SvgLengthPercentageOrNumber::LengthPercentage(
LengthPercentage::new(Au(coord).into(), None)
)
},
CoordDataValue::Percent(p) => {
SvgLengthOrPercentageOrNumber::LengthOrPercentage(
LengthOrPercentage::new(Au(0).into(), Some(Percentage(p)))
SvgLengthPercentageOrNumber::LengthPercentage(
LengthPercentage::new(Au(0).into(), Some(Percentage(p)))
)
},
CoordDataValue::Calc(calc) => {
SvgLengthOrPercentageOrNumber::LengthOrPercentage(calc.into())
SvgLengthPercentageOrNumber::LengthPercentage(calc.into())
},
_ => unreachable!("Unexpected coordinate in ${ident}"),
};
@ -1269,12 +1269,12 @@ pub fn clone_transform_from_list(
#[allow(non_snake_case)]
pub fn clone_${ident}(&self) -> values::computed::TransformOrigin {
use crate::values::computed::{Length, LengthOrPercentage, TransformOrigin};
use crate::values::computed::{Length, LengthPercentage, TransformOrigin};
TransformOrigin {
horizontal: LengthOrPercentage::from_gecko_style_coord(&self.gecko.${gecko_ffi_name}[0])
.expect("clone for LengthOrPercentage failed"),
vertical: LengthOrPercentage::from_gecko_style_coord(&self.gecko.${gecko_ffi_name}[1])
.expect("clone for LengthOrPercentage failed"),
horizontal: LengthPercentage::from_gecko_style_coord(&self.gecko.${gecko_ffi_name}[0])
.expect("clone for LengthPercentage failed"),
vertical: LengthPercentage::from_gecko_style_coord(&self.gecko.${gecko_ffi_name}[1])
.expect("clone for LengthPercentage failed"),
depth: if let Some(third) = self.gecko.${gecko_ffi_name}.get(2) {
Length::from_gecko_style_coord(third)
.expect("clone for Length failed")
@ -1402,19 +1402,19 @@ impl Clone for ${style_struct.gecko_struct_name} {
"length::LengthOrAuto": impl_style_coord,
"length::LengthOrNormal": impl_style_coord,
"length::NonNegativeLengthOrAuto": impl_style_coord,
"length::NonNegativeLengthOrPercentageOrNormal": impl_style_coord,
"length::NonNegativeLengthPercentageOrNormal": impl_style_coord,
"FillRule": impl_simple,
"FlexBasis": impl_style_coord,
"Length": impl_absolute_length,
"LengthOrNormal": impl_style_coord,
"LengthOrPercentage": impl_style_coord,
"LengthOrPercentageOrAuto": impl_style_coord,
"LengthOrPercentageOrNone": impl_style_coord,
"LengthPercentage": impl_style_coord,
"LengthPercentageOrAuto": impl_style_coord,
"LengthPercentageOrNone": impl_style_coord,
"MaxLength": impl_style_coord,
"MozLength": impl_style_coord,
"MozScriptMinSize": impl_absolute_length,
"MozScriptSizeMultiplier": impl_simple,
"NonNegativeLengthOrPercentage": impl_style_coord,
"NonNegativeLengthPercentage": impl_style_coord,
"NonNegativeNumber": impl_simple,
"Number": impl_simple,
"Opacity": impl_simple,
@ -3084,7 +3084,7 @@ fn static_assert() {
}
pub fn clone_vertical_align(&self) -> longhands::vertical_align::computed_value::T {
use crate::values::computed::LengthOrPercentage;
use crate::values::computed::LengthPercentage;
use crate::values::generics::box_::VerticalAlign;
let gecko = &self.gecko.mVerticalAlign;
@ -3092,7 +3092,7 @@ fn static_assert() {
CoordDataValue::Enumerated(value) => VerticalAlign::from_gecko_keyword(value),
_ => {
VerticalAlign::Length(
LengthOrPercentage::from_gecko_style_coord(gecko).expect(
LengthPercentage::from_gecko_style_coord(gecko).expect(
"expected <length-percentage> for vertical-align",
),
)
@ -3386,11 +3386,11 @@ fn static_assert() {
pub fn clone_perspective_origin(&self) -> longhands::perspective_origin::computed_value::T {
use crate::properties::longhands::perspective_origin::computed_value::T;
use crate::values::computed::LengthOrPercentage;
use crate::values::computed::LengthPercentage;
T {
horizontal: LengthOrPercentage::from_gecko_style_coord(&self.gecko.mPerspectiveOrigin[0])
horizontal: LengthPercentage::from_gecko_style_coord(&self.gecko.mPerspectiveOrigin[0])
.expect("Expected length or percentage for horizontal value of perspective-origin"),
vertical: LengthOrPercentage::from_gecko_style_coord(&self.gecko.mPerspectiveOrigin[1])
vertical: LengthPercentage::from_gecko_style_coord(&self.gecko.mPerspectiveOrigin[1])
.expect("Expected length or percentage for vertical value of perspective-origin"),
}
}
@ -3879,12 +3879,12 @@ fn static_assert() {
pub fn clone_${shorthand}_size(&self) -> longhands::${shorthand}_size::computed_value::T {
use crate::gecko_bindings::structs::nsStyleCoord_CalcValue as CalcValue;
use crate::gecko_bindings::structs::nsStyleImageLayers_Size_DimensionType as DimensionType;
use crate::values::computed::NonNegativeLengthOrPercentageOrAuto;
use crate::values::computed::NonNegativeLengthPercentageOrAuto;
use crate::values::generics::background::BackgroundSize;
fn to_servo(value: CalcValue, ty: u8) -> NonNegativeLengthOrPercentageOrAuto {
fn to_servo(value: CalcValue, ty: u8) -> NonNegativeLengthPercentageOrAuto {
if ty == DimensionType::eAuto as u8 {
NonNegativeLengthOrPercentageOrAuto::auto()
NonNegativeLengthPercentageOrAuto::auto()
} else {
debug_assert_eq!(ty, DimensionType::eLengthPercentage as u8);
value.into()
@ -4575,7 +4575,7 @@ fn static_assert() {
}
pub fn clone_word_spacing(&self) -> longhands::word_spacing::computed_value::T {
use crate::values::computed::LengthOrPercentage;
use crate::values::computed::LengthPercentage;
use crate::values::generics::text::Spacing;
debug_assert!(
matches!(self.gecko.mWordSpacing.as_value(),
@ -4584,7 +4584,7 @@ fn static_assert() {
CoordDataValue::Percent(_) |
CoordDataValue::Calc(_)),
"Unexpected computed value for word-spacing");
LengthOrPercentage::from_gecko_style_coord(&self.gecko.mWordSpacing).map_or(Spacing::Normal, Spacing::Value)
LengthPercentage::from_gecko_style_coord(&self.gecko.mWordSpacing).map_or(Spacing::Normal, Spacing::Value)
}
<%call expr="impl_coord_copy('word_spacing', 'mWordSpacing')"></%call>
@ -5016,7 +5016,7 @@ clip-path
pub fn set_stroke_dasharray(&mut self, v: longhands::stroke_dasharray::computed_value::T) {
use crate::gecko_bindings::structs::nsStyleSVG_STROKE_DASHARRAY_CONTEXT as CONTEXT_VALUE;
use crate::values::generics::svg::{SVGStrokeDashArray, SvgLengthOrPercentageOrNumber};
use crate::values::generics::svg::{SVGStrokeDashArray, SvgLengthPercentageOrNumber};
match v {
SVGStrokeDashArray::Values(v) => {
@ -5027,9 +5027,9 @@ clip-path
}
for (gecko, servo) in self.gecko.mStrokeDasharray.iter_mut().zip(v) {
match servo {
SvgLengthOrPercentageOrNumber::LengthOrPercentage(lop) =>
SvgLengthPercentageOrNumber::LengthPercentage(lop) =>
gecko.set(lop),
SvgLengthOrPercentageOrNumber::Number(num) =>
SvgLengthPercentageOrNumber::Number(num) =>
gecko.set_value(CoordDataValue::Factor(num.into())),
}
}
@ -5059,9 +5059,9 @@ clip-path
pub fn clone_stroke_dasharray(&self) -> longhands::stroke_dasharray::computed_value::T {
use crate::gecko_bindings::structs::nsStyleSVG_STROKE_DASHARRAY_CONTEXT as CONTEXT_VALUE;
use crate::values::computed::LengthOrPercentage;
use crate::values::computed::LengthPercentage;
use crate::values::generics::NonNegative;
use crate::values::generics::svg::{SVGStrokeDashArray, SvgLengthOrPercentageOrNumber};
use crate::values::generics::svg::{SVGStrokeDashArray, SvgLengthPercentageOrNumber};
if self.gecko.mContextFlags & CONTEXT_VALUE != 0 {
debug_assert_eq!(self.gecko.mStrokeDasharray.len(), 0);
@ -5071,16 +5071,16 @@ clip-path
for gecko in self.gecko.mStrokeDasharray.iter() {
match gecko.as_value() {
CoordDataValue::Factor(number) =>
vec.push(SvgLengthOrPercentageOrNumber::Number(number.into())),
vec.push(SvgLengthPercentageOrNumber::Number(number.into())),
CoordDataValue::Coord(coord) =>
vec.push(SvgLengthOrPercentageOrNumber::LengthOrPercentage(
NonNegative(LengthOrPercentage::new(Au(coord).into(), None).into()))),
vec.push(SvgLengthPercentageOrNumber::LengthPercentage(
NonNegative(LengthPercentage::new(Au(coord).into(), None).into()))),
CoordDataValue::Percent(p) =>
vec.push(SvgLengthOrPercentageOrNumber::LengthOrPercentage(
NonNegative(LengthOrPercentage::new_percent(Percentage(p)).into()))),
vec.push(SvgLengthPercentageOrNumber::LengthPercentage(
NonNegative(LengthPercentage::new_percent(Percentage(p)).into()))),
CoordDataValue::Calc(calc) =>
vec.push(SvgLengthOrPercentageOrNumber::LengthOrPercentage(
NonNegative(LengthOrPercentage::from(calc).clamp_to_non_negative()))),
vec.push(SvgLengthPercentageOrNumber::LengthPercentage(
NonNegative(LengthPercentage::from(calc).clamp_to_non_negative()))),
_ => unreachable!(),
}
}

2
components/style/properties/longhands/background.mako.rs
View file

@ -35,7 +35,7 @@ ${helpers.predefined_type(
${helpers.predefined_type(
"background-position-" + axis,
"position::" + direction + "Position",
initial_value="computed::LengthOrPercentage::zero()",
initial_value="computed::LengthPercentage::zero()",
initial_specified_value="SpecifiedValue::initial_specified_value()",
spec="https://drafts.csswg.org/css-backgrounds-4/#propdef-background-position-" + axis,
animation_value_type="ComputedValue",

8
components/style/properties/longhands/border.mako.rs
View file

@ -69,7 +69,7 @@ ${helpers.gecko_keyword_conversion(
type="crate::values::specified::BorderStyle",
)}
// FIXME(#4126): when gfx supports painting it, make this Size2D<LengthOrPercentage>
// FIXME(#4126): when gfx supports painting it, make this Size2D<LengthPercentage>
% for corner in ["top-left", "top-right", "bottom-right", "bottom-left"]:
${helpers.predefined_type(
"border-" + corner + "-radius",
@ -189,7 +189,7 @@ impl crate::values::computed::BorderImageWidth {
use crate::gecko_bindings::structs::nsStyleUnit::{eStyleUnit_Factor, eStyleUnit_Auto};
use crate::gecko_bindings::sugar::ns_style_coord::CoordData;
use crate::gecko::values::GeckoStyleCoordConvertible;
use crate::values::computed::{LengthOrPercentage, Number};
use crate::values::computed::{LengthPercentage, Number};
use crate::values::generics::border::BorderImageSideWidth;
use crate::values::generics::NonNegative;
@ -207,8 +207,8 @@ impl crate::values::computed::BorderImageWidth {
},
_ => {
BorderImageSideWidth::Length(
NonNegative(LengthOrPercentage::from_gecko_style_coord(&sides.data_at(${i}))
.expect("sides[${i}] could not convert to LengthOrPercentage")))
NonNegative(LengthPercentage::from_gecko_style_coord(&sides.data_at(${i}))
.expect("sides[${i}] could not convert to LengthPercentage")))
},
},
% endfor

6
components/style/properties/longhands/box.mako.rs
View file

@ -611,10 +611,10 @@ ${helpers.predefined_type(
${helpers.predefined_type(
"shape-margin",
"NonNegativeLengthOrPercentage",
"computed::NonNegativeLengthOrPercentage::zero()",
"NonNegativeLengthPercentage",
"computed::NonNegativeLengthPercentage::zero()",
products="gecko",
animation_value_type="NonNegativeLengthOrPercentage",
animation_value_type="NonNegativeLengthPercentage",
flags="APPLIES_TO_FIRST_LETTER",
spec="https://drafts.csswg.org/css-shapes/#shape-margin-property",
)}

4
components/style/properties/longhands/inherited_text.mako.rs
View file

@ -53,8 +53,8 @@ ${helpers.single_keyword(
${helpers.predefined_type(
"text-indent",
"LengthOrPercentage",
"computed::LengthOrPercentage::zero()",
"LengthPercentage",
"computed::LengthPercentage::zero()",
animation_value_type="ComputedValue",
spec="https://drafts.csswg.org/css-text/#propdef-text-indent",
allow_quirks=True,

4
components/style/properties/longhands/margin.mako.rs
View file

@ -14,8 +14,8 @@
%>
${helpers.predefined_type(
"margin-%s" % side[0],
"LengthOrPercentageOrAuto",
"computed::LengthOrPercentageOrAuto::zero()",
"LengthPercentageOrAuto",
"computed::LengthPercentageOrAuto::zero()",
alias=maybe_moz_logical_alias(product, side, "-moz-margin-%s"),
allow_quirks=not side[1],
animation_value_type="ComputedValue",

6
components/style/properties/longhands/padding.mako.rs
View file

@ -16,10 +16,10 @@
%>
${helpers.predefined_type(
"padding-%s" % side[0],
"NonNegativeLengthOrPercentage",
"computed::NonNegativeLengthOrPercentage::zero()",
"NonNegativeLengthPercentage",
"computed::NonNegativeLengthPercentage::zero()",
alias=maybe_moz_logical_alias(product, side, "-moz-padding-%s"),
animation_value_type="NonNegativeLengthOrPercentage",
animation_value_type="NonNegativeLengthPercentage",
logical=side[1],
logical_group="padding",
spec=spec,

28
components/style/properties/longhands/position.mako.rs
View file

@ -12,8 +12,8 @@
% for side in PHYSICAL_SIDES:
${helpers.predefined_type(
side,
"LengthOrPercentageOrAuto",
"computed::LengthOrPercentageOrAuto::Auto",
"LengthPercentageOrAuto",
"computed::LengthPercentageOrAuto::Auto",
spec="https://www.w3.org/TR/CSS2/visuren.html#propdef-%s" % side,
flags="GETCS_NEEDS_LAYOUT_FLUSH",
animation_value_type="ComputedValue",
@ -26,8 +26,8 @@
% for side in LOGICAL_SIDES:
${helpers.predefined_type(
"inset-%s" % side,
"LengthOrPercentageOrAuto",
"computed::LengthOrPercentageOrAuto::Auto",
"LengthPercentageOrAuto",
"computed::LengthPercentageOrAuto::Auto",
spec="https://drafts.csswg.org/css-logical-props/#propdef-inset-%s" % side,
flags="GETCS_NEEDS_LAYOUT_FLUSH",
alias="offset-%s:layout.css.offset-logical-properties.enabled" % side,
@ -285,8 +285,8 @@ ${helpers.predefined_type(
// servo versions (no keyword support)
${helpers.predefined_type(
size,
"LengthOrPercentageOrAuto",
"computed::LengthOrPercentageOrAuto::Auto",
"LengthPercentageOrAuto",
"computed::LengthPercentageOrAuto::Auto",
"parse_non_negative",
spec=spec % size,
logical_group="size",
@ -296,8 +296,8 @@ ${helpers.predefined_type(
)}
${helpers.predefined_type(
"min-%s" % size,
"LengthOrPercentage",
"computed::LengthOrPercentage::zero()",
"LengthPercentage",
"computed::LengthPercentage::zero()",
"parse_non_negative",
spec=spec % ("min-%s" % size),
logical_group="min-size",
@ -308,8 +308,8 @@ ${helpers.predefined_type(
)}
${helpers.predefined_type(
"max-%s" % size,
"LengthOrPercentageOrNone",
"computed::LengthOrPercentageOrNone::None",
"LengthPercentageOrNone",
"computed::LengthPercentageOrNone::None",
"parse_non_negative",
spec=spec % ("max-%s" % size),
logical_group="max-size",
@ -408,24 +408,24 @@ ${helpers.predefined_type(
${helpers.predefined_type(
"column-gap",
"length::NonNegativeLengthOrPercentageOrNormal",
"length::NonNegativeLengthPercentageOrNormal",
"Either::Second(Normal)",
alias="grid-column-gap" if product == "gecko" else "",
extra_prefixes="moz",
servo_pref="layout.columns.enabled",
spec="https://drafts.csswg.org/css-align-3/#propdef-column-gap",
animation_value_type="NonNegativeLengthOrPercentageOrNormal",
animation_value_type="NonNegativeLengthPercentageOrNormal",
servo_restyle_damage="reflow",
)}
// no need for -moz- prefixed alias for this property
${helpers.predefined_type(
"row-gap",
"length::NonNegativeLengthOrPercentageOrNormal",
"length::NonNegativeLengthPercentageOrNormal",
"Either::Second(Normal)",
alias="grid-row-gap",
products="gecko",
spec="https://drafts.csswg.org/css-align-3/#propdef-row-gap",
animation_value_type="NonNegativeLengthOrPercentageOrNormal",
animation_value_type="NonNegativeLengthPercentageOrNormal",
servo_restyle_damage="reflow",
)}

2
components/style/properties/longhands/svg.mako.rs
View file

@ -118,7 +118,7 @@ ${helpers.predefined_type(
${helpers.predefined_type(
"mask-position-" + axis,
"position::" + direction + "Position",
"computed::LengthOrPercentage::zero()",
"computed::LengthPercentage::zero()",
products="gecko",
extra_prefixes="webkit",
initial_specified_value="specified::PositionComponent::Center",

18
components/style/properties/properties.mako.rs
View file

@ -3017,7 +3017,7 @@ impl ComputedValuesInner {
/// Get the logical computed inline size.
#[inline]
pub fn content_inline_size(&self) -> computed::LengthOrPercentageOrAuto {
pub fn content_inline_size(&self) -> computed::LengthPercentageOrAuto {
let position_style = self.get_position();
if self.writing_mode.is_vertical() {
position_style.height
@ -3028,42 +3028,42 @@ impl ComputedValuesInner {
/// Get the logical computed block size.
#[inline]
pub fn content_block_size(&self) -> computed::LengthOrPercentageOrAuto {
pub fn content_block_size(&self) -> computed::LengthPercentageOrAuto {
let position_style = self.get_position();
if self.writing_mode.is_vertical() { position_style.width } else { position_style.height }
}
/// Get the logical computed min inline size.
#[inline]
pub fn min_inline_size(&self) -> computed::LengthOrPercentage {
pub fn min_inline_size(&self) -> computed::LengthPercentage {
let position_style = self.get_position();
if self.writing_mode.is_vertical() { position_style.min_height } else { position_style.min_width }
}
/// Get the logical computed min block size.
#[inline]
pub fn min_block_size(&self) -> computed::LengthOrPercentage {
pub fn min_block_size(&self) -> computed::LengthPercentage {
let position_style = self.get_position();
if self.writing_mode.is_vertical() { position_style.min_width } else { position_style.min_height }
}
/// Get the logical computed max inline size.
#[inline]
pub fn max_inline_size(&self) -> computed::LengthOrPercentageOrNone {
pub fn max_inline_size(&self) -> computed::LengthPercentageOrNone {
let position_style = self.get_position();
if self.writing_mode.is_vertical() { position_style.max_height } else { position_style.max_width }
}
/// Get the logical computed max block size.
#[inline]
pub fn max_block_size(&self) -> computed::LengthOrPercentageOrNone {
pub fn max_block_size(&self) -> computed::LengthPercentageOrNone {
let position_style = self.get_position();
if self.writing_mode.is_vertical() { position_style.max_width } else { position_style.max_height }
}
/// Get the logical computed padding for this writing mode.
#[inline]
pub fn logical_padding(&self) -> LogicalMargin<computed::LengthOrPercentage> {
pub fn logical_padding(&self) -> LogicalMargin<computed::LengthPercentage> {
let padding_style = self.get_padding();
LogicalMargin::from_physical(self.writing_mode, SideOffsets2D::new(
padding_style.padding_top.0,
@ -3093,7 +3093,7 @@ impl ComputedValuesInner {
/// Gets the logical computed margin from this style.
#[inline]
pub fn logical_margin(&self) -> LogicalMargin<computed::LengthOrPercentageOrAuto> {
pub fn logical_margin(&self) -> LogicalMargin<computed::LengthPercentageOrAuto> {
let margin_style = self.get_margin();
LogicalMargin::from_physical(self.writing_mode, SideOffsets2D::new(
margin_style.margin_top,
@ -3105,7 +3105,7 @@ impl ComputedValuesInner {
/// Gets the logical position from this style.
#[inline]
pub fn logical_position(&self) -> LogicalMargin<computed::LengthOrPercentageOrAuto> {
pub fn logical_position(&self) -> LogicalMargin<computed::LengthPercentageOrAuto> {
// FIXME(SimonSapin): should be the writing mode of the containing block, maybe?
let position_style = self.get_position();
LogicalMargin::from_physical(self.writing_mode, SideOffsets2D::new(

2
components/style/properties/shorthands/margin.mako.rs
View file

@ -4,7 +4,7 @@
<%namespace name="helpers" file="/helpers.mako.rs" />
${helpers.four_sides_shorthand("margin", "margin-%s", "specified::LengthOrPercentageOrAuto::parse",
${helpers.four_sides_shorthand("margin", "margin-%s", "specified::LengthPercentageOrAuto::parse",
spec="https://drafts.csswg.org/css-box/#propdef-margin",
allowed_in_page_rule=True,
allow_quirks=True)}

2
components/style/properties/shorthands/padding.mako.rs
View file

@ -4,6 +4,6 @@
<%namespace name="helpers" file="/helpers.mako.rs" />
${helpers.four_sides_shorthand("padding", "padding-%s", "specified::NonNegativeLengthOrPercentage::parse",
${helpers.four_sides_shorthand("padding", "padding-%s", "specified::NonNegativeLengthPercentage::parse",
spec="https://drafts.csswg.org/css-box-3/#propdef-padding",
allow_quirks=True)}

18
components/style/stylesheets/viewport_rule.rs
View file

@ -18,7 +18,7 @@ use crate::shared_lock::{SharedRwLockReadGuard, StylesheetGuards, ToCssWithGuard
use crate::str::CssStringWriter;
use crate::stylesheets::{Origin, StylesheetInDocument};
use crate::values::computed::{Context, ToComputedValue};
use crate::values::specified::{self, LengthOrPercentageOrAuto, NoCalcLength, ViewportPercentageLength};
use crate::values::specified::{self, LengthPercentageOrAuto, NoCalcLength, ViewportPercentageLength};
use app_units::Au;
use cssparser::CowRcStr;
use cssparser::{parse_important, AtRuleParser, DeclarationListParser, DeclarationParser, Parser};
@ -149,7 +149,7 @@ trait FromMeta: Sized {
#[cfg_attr(feature = "servo", derive(MallocSizeOf))]
#[derive(Clone, Debug, PartialEq, ToCss)]
pub enum ViewportLength {
Specified(LengthOrPercentageOrAuto),
Specified(LengthPercentageOrAuto),
ExtendToZoom,
}
@ -157,8 +157,8 @@ impl FromMeta for ViewportLength {
fn from_meta(value: &str) -> Option<ViewportLength> {
macro_rules! specified {
($value:expr) => {
ViewportLength::Specified(LengthOrPercentageOrAuto::LengthOrPercentage(
specified::LengthOrPercentage::Length($value)
ViewportLength::Specified(LengthPercentageOrAuto::LengthPercentage(
specified::LengthPercentage::Length($value)
))
};
}
@ -186,7 +186,7 @@ impl ViewportLength {
) -> Result<Self, ParseError<'i>> {
// we explicitly do not accept 'extend-to-zoom', since it is a UA
// internal value for <META> viewport translation
LengthOrPercentageOrAuto::parse_non_negative(context, input).map(ViewportLength::Specified)
LengthPercentageOrAuto::parse_non_negative(context, input).map(ViewportLength::Specified)
}
}
@ -468,10 +468,10 @@ impl ViewportRule {
if !has_width && has_zoom {
if has_height {
push_descriptor!(MinWidth(ViewportLength::Specified(
LengthOrPercentageOrAuto::Auto
LengthPercentageOrAuto::Auto
)));
push_descriptor!(MaxWidth(ViewportLength::Specified(
LengthOrPercentageOrAuto::Auto
LengthPercentageOrAuto::Auto
)));
} else {
push_descriptor!(MinWidth(ViewportLength::ExtendToZoom));
@ -754,8 +754,8 @@ impl MaybeNew for ViewportConstraints {
if let Some($value) = $value {
match *$value {
ViewportLength::Specified(ref length) => match *length {
LengthOrPercentageOrAuto::Auto => None,
LengthOrPercentageOrAuto::LengthOrPercentage(ref lop) => Some(lop
LengthPercentageOrAuto::Auto => None,
LengthPercentageOrAuto::LengthPercentage(ref lop) => Some(lop
.to_computed_value(&context)
.to_used_value(initial_viewport.$dimension)),
},

20
components/style/values/animated/length.rs
View file

@ -5,13 +5,13 @@
//! Animation implementation for various length-related types.
use super::{Animate, Procedure, ToAnimatedValue};
use crate::values::computed::length::LengthOrPercentage;
use crate::values::computed::length::LengthPercentage;
use crate::values::computed::MaxLength as ComputedMaxLength;
use crate::values::computed::MozLength as ComputedMozLength;
use crate::values::computed::Percentage;
/// <https://drafts.csswg.org/css-transitions/#animtype-lpcalc>
impl Animate for LengthOrPercentage {
impl Animate for LengthPercentage {
#[inline]
fn animate(&self, other: &Self, procedure: Procedure) -> Result<Self, ()> {
let animate_percentage_half = |this: Option<Percentage>, other: Option<Percentage>| {
@ -48,17 +48,17 @@ impl ToAnimatedValue for ComputedMaxLength {
#[inline]
fn from_animated_value(animated: Self::AnimatedValue) -> Self {
use crate::values::computed::LengthOrPercentageOrNone;
use crate::values::computed::LengthPercentageOrNone;
use crate::values::generics::length::MaxLength as GenericMaxLength;
match animated {
GenericMaxLength::LengthOrPercentageOrNone(lopn) => {
GenericMaxLength::LengthPercentageOrNone(lopn) => {
let result = match lopn {
LengthOrPercentageOrNone::LengthOrPercentage(len) => {
LengthOrPercentageOrNone::LengthOrPercentage(len.clamp_to_non_negative())
LengthPercentageOrNone::LengthPercentage(len) => {
LengthPercentageOrNone::LengthPercentage(len.clamp_to_non_negative())
},
LengthOrPercentageOrNone::None => lopn,
LengthPercentageOrNone::None => lopn,
};
GenericMaxLength::LengthOrPercentageOrNone(result)
GenericMaxLength::LengthPercentageOrNone(result)
},
_ => animated,
}
@ -77,8 +77,8 @@ impl ToAnimatedValue for ComputedMozLength {
fn from_animated_value(animated: Self::AnimatedValue) -> Self {
use crate::values::generics::length::MozLength as GenericMozLength;
match animated {
GenericMozLength::LengthOrPercentageOrAuto(lopa) => {
GenericMozLength::LengthOrPercentageOrAuto(lopa.clamp_to_non_negative())
GenericMozLength::LengthPercentageOrAuto(lopa) => {
GenericMozLength::LengthPercentageOrAuto(lopa.clamp_to_non_negative())
},
_ => animated,
}

4
components/style/values/animated/mod.rs
View file

@ -9,7 +9,7 @@
//! module's raison d'être is to ultimately contain all these types.
use crate::properties::PropertyId;
use crate::values::computed::length::LengthOrPercentage;
use crate::values::computed::length::LengthPercentage;
use crate::values::computed::url::ComputedUrl;
use crate::values::computed::Angle as ComputedAngle;
use crate::values::computed::Image;
@ -335,7 +335,7 @@ macro_rules! trivial_to_animated_value {
}
trivial_to_animated_value!(Au);
trivial_to_animated_value!(LengthOrPercentage);
trivial_to_animated_value!(LengthPercentage);
trivial_to_animated_value!(ComputedAngle);
trivial_to_animated_value!(ComputedUrl);
trivial_to_animated_value!(bool);

20
components/style/values/animated/svg.rs
View file

@ -8,9 +8,9 @@ use super::{Animate, Procedure, ToAnimatedZero};
use crate::properties::animated_properties::ListAnimation;
use crate::values::animated::color::Color as AnimatedColor;
use crate::values::computed::url::ComputedUrl;
use crate::values::computed::{LengthOrPercentage, Number, NumberOrPercentage};
use crate::values::computed::{LengthPercentage, Number, NumberOrPercentage};
use crate::values::distance::{ComputeSquaredDistance, SquaredDistance};
use crate::values::generics::svg::{SVGLength, SVGPaint, SvgLengthOrPercentageOrNumber};
use crate::values::generics::svg::{SVGLength, SVGPaint, SvgLengthPercentageOrNumber};
use crate::values::generics::svg::{SVGOpacity, SVGStrokeDashArray};
/// Animated SVGPaint.
@ -29,10 +29,10 @@ impl ToAnimatedZero for IntermediateSVGPaint {
// FIXME: We need to handle calc here properly, see
// https://bugzilla.mozilla.org/show_bug.cgi?id=1386967
fn to_number_or_percentage(
value: &SvgLengthOrPercentageOrNumber<LengthOrPercentage, Number>,
value: &SvgLengthPercentageOrNumber<LengthPercentage, Number>,
) -> Result<NumberOrPercentage, ()> {
Ok(match *value {
SvgLengthOrPercentageOrNumber::LengthOrPercentage(ref l) => {
SvgLengthPercentageOrNumber::LengthPercentage(ref l) => {
match l.percentage {
Some(p) => {
if l.unclamped_length().px() != 0. {
@ -43,11 +43,11 @@ fn to_number_or_percentage(
None => NumberOrPercentage::Number(l.length().px())
}
},
SvgLengthOrPercentageOrNumber::Number(ref n) => NumberOrPercentage::Number(*n),
SvgLengthPercentageOrNumber::Number(ref n) => NumberOrPercentage::Number(*n),
})
}
impl Animate for SvgLengthOrPercentageOrNumber<LengthOrPercentage, Number> {
impl Animate for SvgLengthPercentageOrNumber<LengthPercentage, Number> {
#[inline]
fn animate(&self, other: &Self, procedure: Procedure) -> Result<Self, ()> {
let this = to_number_or_percentage(self)?;
@ -55,20 +55,20 @@ impl Animate for SvgLengthOrPercentageOrNumber<LengthOrPercentage, Number> {
match (this, other) {
(NumberOrPercentage::Number(ref this), NumberOrPercentage::Number(ref other)) => Ok(
SvgLengthOrPercentageOrNumber::Number(this.animate(other, procedure)?),
SvgLengthPercentageOrNumber::Number(this.animate(other, procedure)?),
),
(
NumberOrPercentage::Percentage(ref this),
NumberOrPercentage::Percentage(ref other),
) => Ok(SvgLengthOrPercentageOrNumber::LengthOrPercentage(
LengthOrPercentage::new_percent(this.animate(other, procedure)?),
) => Ok(SvgLengthPercentageOrNumber::LengthPercentage(
LengthPercentage::new_percent(this.animate(other, procedure)?),
)),
_ => Err(()),
}
}
}
impl ComputeSquaredDistance for SvgLengthOrPercentageOrNumber<LengthOrPercentage, Number> {
impl ComputeSquaredDistance for SvgLengthPercentageOrNumber<LengthPercentage, Number> {
fn compute_squared_distance(&self, other: &Self) -> Result<SquaredDistance, ()> {
to_number_or_percentage(self)?.compute_squared_distance(&to_number_or_percentage(other)?)
}

12
components/style/values/animated/transform.rs
View file

@ -16,7 +16,7 @@ use crate::values::computed::transform::TransformOperation as ComputedTransformO
use crate::values::computed::transform::Translate as ComputedTranslate;
use crate::values::computed::transform::{DirectionVector, Matrix, Matrix3D};
use crate::values::computed::Angle;
use crate::values::computed::{Length, LengthOrPercentage};
use crate::values::computed::{Length, LengthPercentage};
use crate::values::computed::{Number, Percentage};
use crate::values::distance::{ComputeSquaredDistance, SquaredDistance};
use crate::values::generics::transform::{self, Transform, TransformOperation};
@ -1043,8 +1043,8 @@ impl Animate for ComputedTransformOperation {
) => Ok(TransformOperation::Translate(
fx.animate(tx, procedure)?,
Some(
fy.unwrap_or(LengthOrPercentage::zero())
.animate(&ty.unwrap_or(LengthOrPercentage::zero()), procedure)?,
fy.unwrap_or(LengthPercentage::zero())
.animate(&ty.unwrap_or(LengthPercentage::zero()), procedure)?,
),
)),
(&TransformOperation::TranslateX(ref f), &TransformOperation::TranslateX(ref t)) => {
@ -1383,15 +1383,15 @@ impl ComputeSquaredDistance for ComputedRotate {
/// <https://drafts.csswg.org/css-transforms-2/#propdef-translate>
impl ComputedTranslate {
fn resolve(&self) -> (LengthOrPercentage, LengthOrPercentage, Length) {
fn resolve(&self) -> (LengthPercentage, LengthPercentage, Length) {
// According to the spec:
// https://drafts.csswg.org/css-transforms-2/#individual-transforms
//
// Unspecified translations default to 0px
match *self {
Translate::None => (
LengthOrPercentage::zero(),
LengthOrPercentage::zero(),
LengthPercentage::zero(),
LengthPercentage::zero(),
Length::zero(),
),
Translate::Translate3D(tx, ty, tz) => (tx, ty, tz),

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

@ -4,20 +4,20 @@
//! Computed types for CSS values related to backgrounds.
use crate::values::computed::length::NonNegativeLengthOrPercentageOrAuto;
use crate::values::computed::length::NonNegativeLengthPercentageOrAuto;
use crate::values::generics::background::BackgroundSize as GenericBackgroundSize;
pub use crate::values::specified::background::BackgroundRepeat;
/// A computed value for the `background-size` property.
pub type BackgroundSize = GenericBackgroundSize<NonNegativeLengthOrPercentageOrAuto>;
pub type BackgroundSize = GenericBackgroundSize<NonNegativeLengthPercentageOrAuto>;
impl BackgroundSize {
/// Returns `auto auto`.
pub fn auto() -> Self {
GenericBackgroundSize::Explicit {
width: NonNegativeLengthOrPercentageOrAuto::auto(),
height: NonNegativeLengthOrPercentageOrAuto::auto(),
width: NonNegativeLengthPercentageOrAuto::auto(),
height: NonNegativeLengthPercentageOrAuto::auto(),
}
}
}

18
components/style/values/computed/basic_shape.rs
View file

@ -8,7 +8,7 @@
//! [basic-shape]: https://drafts.csswg.org/css-shapes/#typedef-basic-shape
use crate::values::computed::url::ComputedUrl;
use crate::values::computed::{Image, LengthOrPercentage, NonNegativeLengthOrPercentage};
use crate::values::computed::{Image, LengthPercentage, NonNegativeLengthPercentage};
use crate::values::generics::basic_shape as generic;
use std::fmt::{self, Write};
use style_traits::{CssWriter, ToCss};
@ -24,25 +24,25 @@ pub type FloatAreaShape = generic::FloatAreaShape<BasicShape, Image>;
/// A computed basic shape.
pub type BasicShape = generic::BasicShape<
LengthOrPercentage,
LengthOrPercentage,
LengthOrPercentage,
NonNegativeLengthOrPercentage,
LengthPercentage,
LengthPercentage,
LengthPercentage,
NonNegativeLengthPercentage,
>;
/// The computed value of `inset()`
pub type InsetRect = generic::InsetRect<LengthOrPercentage, NonNegativeLengthOrPercentage>;
pub type InsetRect = generic::InsetRect<LengthPercentage, NonNegativeLengthPercentage>;
/// A computed circle.
pub type Circle =
generic::Circle<LengthOrPercentage, LengthOrPercentage, NonNegativeLengthOrPercentage>;
generic::Circle<LengthPercentage, LengthPercentage, NonNegativeLengthPercentage>;
/// A computed ellipse.
pub type Ellipse =
generic::Ellipse<LengthOrPercentage, LengthOrPercentage, NonNegativeLengthOrPercentage>;
generic::Ellipse<LengthPercentage, LengthPercentage, NonNegativeLengthPercentage>;
/// The computed value of `ShapeRadius`
pub type ShapeRadius = generic::ShapeRadius<NonNegativeLengthOrPercentage>;
pub type ShapeRadius = generic::ShapeRadius<NonNegativeLengthPercentage>;
impl ToCss for Circle {
fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result

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

@ -4,7 +4,7 @@
//! Computed types for CSS values related to borders.
use crate::values::computed::length::{NonNegativeLength, NonNegativeLengthOrPercentage};
use crate::values::computed::length::{NonNegativeLength, NonNegativeLengthPercentage};
use crate::values::computed::{NonNegativeNumber, NonNegativeNumberOrPercentage};
use crate::values::generics::border::BorderCornerRadius as GenericBorderCornerRadius;
use crate::values::generics::border::BorderImageSideWidth as GenericBorderImageSideWidth;
@ -23,16 +23,16 @@ pub type BorderImageWidth = Rect<BorderImageSideWidth>;
/// A computed value for a single side of a `border-image-width` property.
pub type BorderImageSideWidth =
GenericBorderImageSideWidth<NonNegativeLengthOrPercentage, NonNegativeNumber>;
GenericBorderImageSideWidth<NonNegativeLengthPercentage, NonNegativeNumber>;
/// A computed value for the `border-image-slice` property.
pub type BorderImageSlice = GenericBorderImageSlice<NonNegativeNumberOrPercentage>;
/// A computed value for the `border-radius` property.
pub type BorderRadius = GenericBorderRadius<NonNegativeLengthOrPercentage>;
pub type BorderRadius = GenericBorderRadius<NonNegativeLengthPercentage>;
/// A computed value for the `border-*-radius` longhand properties.
pub type BorderCornerRadius = GenericBorderCornerRadius<NonNegativeLengthOrPercentage>;
pub type BorderCornerRadius = GenericBorderCornerRadius<NonNegativeLengthPercentage>;
/// A computed value for the `border-spacing` longhand property.
pub type BorderSpacing = GenericBorderSpacing<NonNegativeLength>;
@ -80,8 +80,8 @@ impl BorderCornerRadius {
/// Returns `0 0`.
pub fn zero() -> Self {
GenericBorderCornerRadius(Size::new(
NonNegativeLengthOrPercentage::zero(),
NonNegativeLengthOrPercentage::zero(),
NonNegativeLengthPercentage::zero(),
NonNegativeLengthPercentage::zero(),
))
}
}
@ -90,8 +90,8 @@ impl BorderRadius {
/// Returns whether all the values are `0px`.
pub fn all_zero(&self) -> bool {
fn all(corner: &BorderCornerRadius) -> bool {
fn is_zero(l: &NonNegativeLengthOrPercentage) -> bool {
*l == NonNegativeLengthOrPercentage::zero()
fn is_zero(l: &NonNegativeLengthPercentage) -> bool {
*l == NonNegativeLengthPercentage::zero()
}
is_zero(corner.0.width()) && is_zero(corner.0.height())
}

4
components/style/values/computed/box.rs
View file

@ -4,7 +4,7 @@
//! Computed types for box properties.
use crate::values::computed::length::{LengthOrPercentage, NonNegativeLength};
use crate::values::computed::length::{LengthPercentage, NonNegativeLength};
use crate::values::computed::{Context, Number, ToComputedValue};
use crate::values::generics::box_::AnimationIterationCount as GenericAnimationIterationCount;
use crate::values::generics::box_::Perspective as GenericPerspective;
@ -18,7 +18,7 @@ pub use crate::values::specified::box_::{OverscrollBehavior, ScrollSnapType};
pub use crate::values::specified::box_::{TouchAction, TransitionProperty, WillChange};
/// A computed value for the `vertical-align` property.
pub type VerticalAlign = GenericVerticalAlign<LengthOrPercentage>;
pub type VerticalAlign = GenericVerticalAlign<LengthPercentage>;
/// A computed value for the `animation-iteration-count` property.
pub type AnimationIterationCount = GenericAnimationIterationCount<Number>;

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

@ -8,7 +8,7 @@ use crate::values::generics::flex::FlexBasis as GenericFlexBasis;
/// The `width` value type.
#[cfg(feature = "servo")]
pub type Width = crate::values::computed::NonNegativeLengthOrPercentageOrAuto;
pub type Width = crate::values::computed::NonNegativeLengthPercentageOrAuto;
/// The `width` value type.
#[cfg(feature = "gecko")]

4
components/style/values/computed/gecko.rs
View file

@ -4,8 +4,8 @@
//! Computed types for legacy Gecko-only properties.
use crate::values::computed::length::LengthOrPercentage;
use crate::values::computed::length::LengthPercentage;
use crate::values::generics::gecko::ScrollSnapPoint as GenericScrollSnapPoint;
/// A computed type for scroll snap points.
pub type ScrollSnapPoint = GenericScrollSnapPoint<LengthOrPercentage>;
pub type ScrollSnapPoint = GenericScrollSnapPoint<LengthPercentage>;

12
components/style/values/computed/image.rs
View file

@ -10,7 +10,7 @@
use crate::values::computed::position::Position;
use crate::values::computed::url::ComputedImageUrl;
use crate::values::computed::{Angle, Color, Context};
use crate::values::computed::{Length, LengthOrPercentage, NumberOrPercentage, ToComputedValue};
use crate::values::computed::{Length, LengthPercentage, NumberOrPercentage, ToComputedValue};
use crate::values::generics::image::{self as generic, CompatMode};
use crate::values::specified::image::LineDirection as SpecifiedLineDirection;
use crate::values::specified::position::{X, Y};
@ -29,11 +29,11 @@ pub type Image = generic::Image<Gradient, MozImageRect, ComputedImageUrl>;
/// Computed values for a CSS gradient.
/// <https://drafts.csswg.org/css-images/#gradients>
pub type Gradient =
generic::Gradient<LineDirection, Length, LengthOrPercentage, Position, Color, Angle>;
generic::Gradient<LineDirection, Length, LengthPercentage, Position, Color, Angle>;
/// A computed gradient kind.
pub type GradientKind =
generic::GradientKind<LineDirection, Length, LengthOrPercentage, Position, Angle>;
generic::GradientKind<LineDirection, Length, LengthPercentage, Position, Angle>;
/// A computed gradient line direction.
#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq)]
@ -52,13 +52,13 @@ pub enum LineDirection {
}
/// A computed radial gradient ending shape.
pub type EndingShape = generic::EndingShape<Length, LengthOrPercentage>;
pub type EndingShape = generic::EndingShape<Length, LengthPercentage>;
/// A computed gradient item.
pub type GradientItem = generic::GradientItem<Color, LengthOrPercentage>;
pub type GradientItem = generic::GradientItem<Color, LengthPercentage>;
/// A computed color stop.
pub type ColorStop = generic::ColorStop<Color, LengthOrPercentage>;
pub type ColorStop = generic::ColorStop<Color, LengthPercentage>;
/// Computed values for `-moz-image-rect(...)`.
pub type MozImageRect = generic::MozImageRect<NumberOrPercentage, ComputedImageUrl>;

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

@ -67,9 +67,13 @@ impl ToComputedValue for specified::Length {
}
}
/// A `<length-percentage>` value. This can be either a `<length>`, a
/// `<percentage>`, or a combination of both via `calc()`.
///
/// https://drafts.csswg.org/css-values-4/#typedef-length-percentage
#[allow(missing_docs)]
#[derive(Clone, Copy, Debug, MallocSizeOf, ToAnimatedZero)]
pub struct LengthOrPercentage {
pub struct LengthPercentage {
#[animation(constant)]
pub clamping_mode: AllowedNumericType,
length: Length,
@ -87,19 +91,19 @@ pub struct LengthOrPercentage {
}
// FIXME(emilio): This is a bit of a hack that can disappear as soon as we share
// representation of LengthOrPercentage with Gecko. The issue here is that Gecko
// representation of LengthPercentage with Gecko. The issue here is that Gecko
// uses CalcValue to represent position components, so they always come back as
// was_calc == true, and we mess up in the transitions code.
//
// This was a pre-existing bug, though arguably so only in pretty obscure cases
// like calc(0px + 5%) and such.
impl PartialEq for LengthOrPercentage {
impl PartialEq for LengthPercentage {
fn eq(&self, other: &Self) -> bool {
self.length == other.length && self.percentage == other.percentage
}
}
impl ComputeSquaredDistance for LengthOrPercentage {
impl ComputeSquaredDistance for LengthPercentage {
#[inline]
fn compute_squared_distance(&self, other: &Self) -> Result<SquaredDistance, ()> {
// FIXME(nox): This looks incorrect to me, to add a distance between lengths
@ -112,8 +116,8 @@ impl ComputeSquaredDistance for LengthOrPercentage {
}
}
impl LengthOrPercentage {
/// Returns a new `LengthOrPercentage`.
impl LengthPercentage {
/// Returns a new `LengthPercentage`.
#[inline]
pub fn new(length: Length, percentage: Option<Percentage>) -> Self {
Self::with_clamping_mode(
@ -124,12 +128,12 @@ impl LengthOrPercentage {
)
}
/// Returns a new `LengthOrPercentage` with zero length and some percentage.
/// Returns a new `LengthPercentage` with zero length and some percentage.
pub fn new_percent(percentage: Percentage) -> Self {
Self::new(Length::zero(), Some(percentage))
}
/// Returns a new `LengthOrPercentage` with a specific clamping mode.
/// Returns a new `LengthPercentage` with a specific clamping mode.
#[inline]
pub fn with_clamping_mode(
length: Length,
@ -209,23 +213,23 @@ impl LengthOrPercentage {
}
}
impl ToCss for LengthOrPercentage {
impl ToCss for LengthPercentage {
fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
where
W: Write,
{
specified::LengthOrPercentage::from_computed_value(self).to_css(dest)
specified::LengthPercentage::from_computed_value(self).to_css(dest)
}
}
impl specified::CalcLengthOrPercentage {
impl specified::CalcLengthPercentage {
/// Compute the value, zooming any absolute units by the zoom function.
fn to_computed_value_with_zoom<F>(
&self,
context: &Context,
zoom_fn: F,
base_size: FontBaseSize,
) -> LengthOrPercentage
) -> LengthPercentage
where
F: Fn(Length) -> Length,
{
@ -259,7 +263,7 @@ impl specified::CalcLengthOrPercentage {
}
}
LengthOrPercentage {
LengthPercentage {
clamping_mode: self.clamping_mode,
length: Length::new(length.min(f32::MAX).max(f32::MIN)),
percentage: self.percentage,
@ -272,7 +276,7 @@ impl specified::CalcLengthOrPercentage {
&self,
context: &Context,
base_size: FontBaseSize,
) -> LengthOrPercentage {
) -> LengthPercentage {
self.to_computed_value_with_zoom(
context,
|abs| context.maybe_zoom_text(abs.into()).0,
@ -306,17 +310,17 @@ impl specified::CalcLengthOrPercentage {
}
}
impl ToComputedValue for specified::CalcLengthOrPercentage {
type ComputedValue = LengthOrPercentage;
impl ToComputedValue for specified::CalcLengthPercentage {
type ComputedValue = LengthPercentage;
fn to_computed_value(&self, context: &Context) -> LengthOrPercentage {
fn to_computed_value(&self, context: &Context) -> LengthPercentage {
// normal properties don't zoom, and compute em units against the current style's font-size
self.to_computed_value_with_zoom(context, |abs| abs, FontBaseSize::CurrentStyle)
}
#[inline]
fn from_computed_value(computed: &LengthOrPercentage) -> Self {
specified::CalcLengthOrPercentage {
fn from_computed_value(computed: &LengthPercentage) -> Self {
specified::CalcLengthPercentage {
clamping_mode: computed.clamping_mode,
absolute: Some(AbsoluteLength::from_computed_value(&computed.length)),
percentage: computed.percentage,
@ -325,17 +329,17 @@ impl ToComputedValue for specified::CalcLengthOrPercentage {
}
}
impl LengthOrPercentage {
impl LengthPercentage {
#[inline]
#[allow(missing_docs)]
pub fn zero() -> LengthOrPercentage {
LengthOrPercentage::new(Length::new(0.), None)
pub fn zero() -> LengthPercentage {
LengthPercentage::new(Length::new(0.), None)
}
/// 1px length value for SVG defaults
#[inline]
pub fn one() -> LengthOrPercentage {
LengthOrPercentage::new(Length::new(1.), None)
pub fn one() -> LengthPercentage {
LengthPercentage::new(Length::new(1.), None)
}
/// Returns true if the computed value is absolute 0 or 0%.
@ -398,44 +402,44 @@ impl LengthOrPercentage {
}
}
impl ToComputedValue for specified::LengthOrPercentage {
type ComputedValue = LengthOrPercentage;
impl ToComputedValue for specified::LengthPercentage {
type ComputedValue = LengthPercentage;
fn to_computed_value(&self, context: &Context) -> LengthOrPercentage {
fn to_computed_value(&self, context: &Context) -> LengthPercentage {
match *self {
specified::LengthOrPercentage::Length(ref value) => {
LengthOrPercentage::new(value.to_computed_value(context), None)
specified::LengthPercentage::Length(ref value) => {
LengthPercentage::new(value.to_computed_value(context), None)
},
specified::LengthOrPercentage::Percentage(value) => {
LengthOrPercentage::new_percent(value)
specified::LengthPercentage::Percentage(value) => {
LengthPercentage::new_percent(value)
},
specified::LengthOrPercentage::Calc(ref calc) => {
specified::LengthPercentage::Calc(ref calc) => {
(**calc).to_computed_value(context)
},
}
}
fn from_computed_value(computed: &LengthOrPercentage) -> Self {
fn from_computed_value(computed: &LengthPercentage) -> Self {
let length = computed.unclamped_length();
if let Some(p) = computed.as_percentage() {
return specified::LengthOrPercentage::Percentage(p)
return specified::LengthPercentage::Percentage(p)
}
let percentage = computed.percentage;
if percentage.is_none() &&
computed.clamping_mode.clamp(length.px()) == length.px() {
return specified::LengthOrPercentage::Length(
return specified::LengthPercentage::Length(
ToComputedValue::from_computed_value(&length)
)
}
specified::LengthOrPercentage::Calc(Box::new(
specified::LengthPercentage::Calc(Box::new(
ToComputedValue::from_computed_value(computed),
))
}
}
impl IsZeroLength for LengthOrPercentage {
impl IsZeroLength for LengthPercentage {
#[inline]
fn is_zero_length(&self) -> bool {
self.is_definitely_zero()
@ -445,39 +449,39 @@ impl IsZeroLength for LengthOrPercentage {
#[allow(missing_docs)]
#[css(derive_debug)]
#[derive(Animate, Clone, ComputeSquaredDistance, Copy, MallocSizeOf, PartialEq, ToAnimatedZero, ToCss)]
pub enum LengthOrPercentageOrAuto {
LengthOrPercentage(LengthOrPercentage),
pub enum LengthPercentageOrAuto {
LengthPercentage(LengthPercentage),
Auto,
}
impl LengthOrPercentageOrAuto {
impl LengthPercentageOrAuto {
/// Returns the `0` value.
#[inline]
pub fn zero() -> Self {
LengthOrPercentageOrAuto::LengthOrPercentage(LengthOrPercentage::zero())
LengthPercentageOrAuto::LengthPercentage(LengthPercentage::zero())
}
}
/// A wrapper of LengthOrPercentageOrAuto, whose value must be >= 0.
pub type NonNegativeLengthOrPercentageOrAuto = NonNegative<LengthOrPercentageOrAuto>;
/// A wrapper of LengthPercentageOrAuto, whose value must be >= 0.
pub type NonNegativeLengthPercentageOrAuto = NonNegative<LengthPercentageOrAuto>;
impl IsAuto for NonNegativeLengthOrPercentageOrAuto {
impl IsAuto for NonNegativeLengthPercentageOrAuto {
#[inline]
fn is_auto(&self) -> bool {
*self == Self::auto()
}
}
impl NonNegativeLengthOrPercentageOrAuto {
impl NonNegativeLengthPercentageOrAuto {
/// `auto`
#[inline]
pub fn auto() -> Self {
NonNegative(LengthOrPercentageOrAuto::Auto)
NonNegative(LengthPercentageOrAuto::Auto)
}
}
impl ToAnimatedValue for NonNegativeLengthOrPercentageOrAuto {
type AnimatedValue = LengthOrPercentageOrAuto;
impl ToAnimatedValue for NonNegativeLengthPercentageOrAuto {
type AnimatedValue = LengthPercentageOrAuto;
#[inline]
fn to_animated_value(self) -> Self::AnimatedValue {
@ -490,48 +494,48 @@ impl ToAnimatedValue for NonNegativeLengthOrPercentageOrAuto {
}
}
impl LengthOrPercentageOrAuto {
impl LengthPercentageOrAuto {
/// Returns true if the computed value is absolute 0 or 0%.
#[inline]
pub fn is_definitely_zero(&self) -> bool {
use self::LengthOrPercentageOrAuto::*;
use self::LengthPercentageOrAuto::*;
match *self {
LengthOrPercentage(ref l) => l.is_definitely_zero(),
LengthPercentage(ref l) => l.is_definitely_zero(),
Auto => false,
}
}
/// Clamps the value to a non-negative value.
pub fn clamp_to_non_negative(self) -> Self {
use self::LengthOrPercentageOrAuto::*;
use self::LengthPercentageOrAuto::*;
match self {
LengthOrPercentage(l) => LengthOrPercentage(l.clamp_to_non_negative()),
LengthPercentage(l) => LengthPercentage(l.clamp_to_non_negative()),
Auto => Auto,
}
}
}
impl ToComputedValue for specified::LengthOrPercentageOrAuto {
type ComputedValue = LengthOrPercentageOrAuto;
impl ToComputedValue for specified::LengthPercentageOrAuto {
type ComputedValue = LengthPercentageOrAuto;
#[inline]
fn to_computed_value(&self, context: &Context) -> LengthOrPercentageOrAuto {
fn to_computed_value(&self, context: &Context) -> LengthPercentageOrAuto {
match *self {
specified::LengthOrPercentageOrAuto::LengthOrPercentage(ref value) => {
LengthOrPercentageOrAuto::LengthOrPercentage(
specified::LengthPercentageOrAuto::LengthPercentage(ref value) => {
LengthPercentageOrAuto::LengthPercentage(
value.to_computed_value(context),
)
},
specified::LengthOrPercentageOrAuto::Auto => LengthOrPercentageOrAuto::Auto,
specified::LengthPercentageOrAuto::Auto => LengthPercentageOrAuto::Auto,
}
}
#[inline]
fn from_computed_value(computed: &LengthOrPercentageOrAuto) -> Self {
fn from_computed_value(computed: &LengthPercentageOrAuto) -> Self {
match *computed {
LengthOrPercentageOrAuto::Auto => specified::LengthOrPercentageOrAuto::Auto,
LengthOrPercentageOrAuto::LengthOrPercentage(ref value) => {
specified::LengthOrPercentageOrAuto::LengthOrPercentage(
LengthPercentageOrAuto::Auto => specified::LengthPercentageOrAuto::Auto,
LengthPercentageOrAuto::LengthPercentage(ref value) => {
specified::LengthPercentageOrAuto::LengthPercentage(
ToComputedValue::from_computed_value(value),
)
},
@ -542,17 +546,17 @@ impl ToComputedValue for specified::LengthOrPercentageOrAuto {
#[allow(missing_docs)]
#[css(derive_debug)]
#[derive(Animate, Clone, ComputeSquaredDistance, Copy, MallocSizeOf, PartialEq, ToAnimatedZero, ToCss)]
pub enum LengthOrPercentageOrNone {
LengthOrPercentage(LengthOrPercentage),
pub enum LengthPercentageOrNone {
LengthPercentage(LengthPercentage),
None,
}
impl LengthOrPercentageOrNone {
impl LengthPercentageOrNone {
/// Returns the used value.
pub fn to_used_value(&self, containing_length: Au) -> Option<Au> {
match *self {
LengthOrPercentageOrNone::None => None,
LengthOrPercentageOrNone::LengthOrPercentage(ref lop) => {
LengthPercentageOrNone::None => None,
LengthPercentageOrNone::LengthPercentage(ref lop) => {
Some(lop.to_used_value(containing_length))
},
}
@ -560,25 +564,25 @@ impl LengthOrPercentageOrNone {
}
// FIXME(emilio): Derive this.
impl ToComputedValue for specified::LengthOrPercentageOrNone {
type ComputedValue = LengthOrPercentageOrNone;
impl ToComputedValue for specified::LengthPercentageOrNone {
type ComputedValue = LengthPercentageOrNone;
#[inline]
fn to_computed_value(&self, context: &Context) -> LengthOrPercentageOrNone {
fn to_computed_value(&self, context: &Context) -> LengthPercentageOrNone {
match *self {
specified::LengthOrPercentageOrNone::LengthOrPercentage(ref value) => {
LengthOrPercentageOrNone::LengthOrPercentage(value.to_computed_value(context))
specified::LengthPercentageOrNone::LengthPercentage(ref value) => {
LengthPercentageOrNone::LengthPercentage(value.to_computed_value(context))
},
specified::LengthOrPercentageOrNone::None => LengthOrPercentageOrNone::None,
specified::LengthPercentageOrNone::None => LengthPercentageOrNone::None,
}
}
#[inline]
fn from_computed_value(computed: &LengthOrPercentageOrNone) -> Self {
fn from_computed_value(computed: &LengthPercentageOrNone) -> Self {
match *computed {
LengthOrPercentageOrNone::None => specified::LengthOrPercentageOrNone::None,
LengthOrPercentageOrNone::LengthOrPercentage(value) => {
specified::LengthOrPercentageOrNone::LengthOrPercentage(
LengthPercentageOrNone::None => specified::LengthPercentageOrNone::None,
LengthPercentageOrNone::LengthPercentage(value) => {
specified::LengthPercentageOrNone::LengthPercentage(
ToComputedValue::from_computed_value(&value),
)
},
@ -586,11 +590,11 @@ impl ToComputedValue for specified::LengthOrPercentageOrNone {
}
}
/// A wrapper of LengthOrPercentage, whose value must be >= 0.
pub type NonNegativeLengthOrPercentage = NonNegative<LengthOrPercentage>;
/// A wrapper of LengthPercentage, whose value must be >= 0.
pub type NonNegativeLengthPercentage = NonNegative<LengthPercentage>;
impl ToAnimatedValue for NonNegativeLengthOrPercentage {
type AnimatedValue = LengthOrPercentage;
impl ToAnimatedValue for NonNegativeLengthPercentage {
type AnimatedValue = LengthPercentage;
#[inline]
fn to_animated_value(self) -> Self::AnimatedValue {
@ -603,41 +607,41 @@ impl ToAnimatedValue for NonNegativeLengthOrPercentage {
}
}
impl From<NonNegativeLength> for NonNegativeLengthOrPercentage {
impl From<NonNegativeLength> for NonNegativeLengthPercentage {
#[inline]
fn from(length: NonNegativeLength) -> Self {
LengthOrPercentage::new(length.0, None).into()
LengthPercentage::new(length.0, None).into()
}
}
impl From<LengthOrPercentage> for NonNegativeLengthOrPercentage {
impl From<LengthPercentage> for NonNegativeLengthPercentage {
#[inline]
fn from(lop: LengthOrPercentage) -> Self {
NonNegative::<LengthOrPercentage>(lop)
fn from(lop: LengthPercentage) -> Self {
NonNegative::<LengthPercentage>(lop)
}
}
impl From<NonNegativeLengthOrPercentage> for LengthOrPercentage {
impl From<NonNegativeLengthPercentage> for LengthPercentage {
#[inline]
fn from(lop: NonNegativeLengthOrPercentage) -> LengthOrPercentage {
fn from(lop: NonNegativeLengthPercentage) -> LengthPercentage {
lop.0
}
}
// TODO(emilio): This is a really generic impl which is only needed to implement
// Animated and co for Spacing<>. Get rid of this, probably?
impl From<Au> for LengthOrPercentage {
impl From<Au> for LengthPercentage {
#[inline]
fn from(length: Au) -> Self {
LengthOrPercentage::new(length.into(), None)
LengthPercentage::new(length.into(), None)
}
}
impl NonNegativeLengthOrPercentage {
impl NonNegativeLengthPercentage {
/// Get zero value.
#[inline]
pub fn zero() -> Self {
NonNegative::<LengthOrPercentage>(LengthOrPercentage::zero())
NonNegative::<LengthPercentage>(LengthPercentage::zero())
}
/// Returns true if the computed value is absolute 0 or 0%.
@ -850,8 +854,8 @@ pub type NonNegativeLengthOrAuto = Either<NonNegativeLength, Auto>;
/// Either a computed NonNegativeLength or the `normal` keyword.
pub type NonNegativeLengthOrNormal = Either<NonNegativeLength, Normal>;
/// Either a computed NonNegativeLengthOrPercentage or the `normal` keyword.
pub type NonNegativeLengthOrPercentageOrNormal = Either<NonNegativeLengthOrPercentage, Normal>;
/// Either a computed NonNegativeLengthPercentage or the `normal` keyword.
pub type NonNegativeLengthPercentageOrNormal = Either<NonNegativeLengthPercentage, Normal>;
/// A type for possible values for min- and max- flavors of width, height,
/// block-size, and inline-size.
@ -881,23 +885,23 @@ pub enum ExtremumLength {
}
/// A computed value for `min-width`, `min-height`, `width` or `height` property.
pub type MozLength = GenericMozLength<LengthOrPercentageOrAuto>;
pub type MozLength = GenericMozLength<LengthPercentageOrAuto>;
impl MozLength {
/// Returns the `auto` value.
#[inline]
pub fn auto() -> Self {
GenericMozLength::LengthOrPercentageOrAuto(LengthOrPercentageOrAuto::Auto)
GenericMozLength::LengthPercentageOrAuto(LengthPercentageOrAuto::Auto)
}
}
/// A computed value for `max-width` or `min-height` property.
pub type MaxLength = GenericMaxLength<LengthOrPercentageOrNone>;
pub type MaxLength = GenericMaxLength<LengthPercentageOrNone>;
impl MaxLength {
/// Returns the `none` value.
#[inline]
pub fn none() -> Self {
GenericMaxLength::LengthOrPercentageOrNone(LengthOrPercentageOrNone::None)
GenericMaxLength::LengthPercentageOrNone(LengthPercentageOrNone::None)
}
}

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

@ -62,9 +62,9 @@ pub use self::font::{MozScriptLevel, MozScriptMinSize, MozScriptSizeMultiplier,
pub use self::gecko::ScrollSnapPoint;
pub use self::image::{Gradient, GradientItem, Image, ImageLayer, LineDirection, MozImageRect};
pub use self::length::{CSSPixelLength, ExtremumLength, NonNegativeLength};
pub use self::length::{Length, LengthOrNumber, LengthOrPercentage};
pub use self::length::{LengthOrPercentageOrAuto, LengthOrPercentageOrNone, MaxLength, MozLength};
pub use self::length::{NonNegativeLengthOrPercentage, NonNegativeLengthOrPercentageOrAuto};
pub use self::length::{Length, LengthOrNumber, LengthPercentage};
pub use self::length::{LengthPercentageOrAuto, LengthPercentageOrNone, MaxLength, MozLength};
pub use self::length::{NonNegativeLengthPercentage, NonNegativeLengthPercentageOrAuto};
#[cfg(feature = "gecko")]
pub use self::list::ListStyleType;
pub use self::list::{QuotePair, Quotes};
@ -689,20 +689,20 @@ impl ToCss for ClipRect {
pub type ClipRectOrAuto = Either<ClipRect, Auto>;
/// The computed value of a grid `<track-breadth>`
pub type TrackBreadth = GenericTrackBreadth<LengthOrPercentage>;
pub type TrackBreadth = GenericTrackBreadth<LengthPercentage>;
/// The computed value of a grid `<track-size>`
pub type TrackSize = GenericTrackSize<LengthOrPercentage>;
pub type TrackSize = GenericTrackSize<LengthPercentage>;
/// The computed value of a grid `<track-list>`
/// (could also be `<auto-track-list>` or `<explicit-track-list>`)
pub type TrackList = GenericTrackList<LengthOrPercentage, Integer>;
pub type TrackList = GenericTrackList<LengthPercentage, Integer>;
/// The computed value of a `<grid-line>`.
pub type GridLine = GenericGridLine<Integer>;
/// `<grid-template-rows> | <grid-template-columns>`
pub type GridTemplateComponent = GenericGridTemplateComponent<LengthOrPercentage, Integer>;
pub type GridTemplateComponent = GenericGridTemplateComponent<LengthPercentage, Integer>;
impl ClipRectOrAuto {
/// Return an auto (default for clip-rect and image-region) value

12
components/style/values/computed/position.rs
View file

@ -7,7 +7,7 @@
//!
//! [position]: https://drafts.csswg.org/css-backgrounds-3/#position
use crate::values::computed::{Integer, LengthOrPercentage, Percentage};
use crate::values::computed::{Integer, LengthPercentage, Percentage};
use crate::values::generics::position::Position as GenericPosition;
use crate::values::generics::position::ZIndex as GenericZIndex;
pub use crate::values::specified::position::{GridAutoFlow, GridTemplateAreas};
@ -18,25 +18,25 @@ use style_traits::{CssWriter, ToCss};
pub type Position = GenericPosition<HorizontalPosition, VerticalPosition>;
/// The computed value of a CSS horizontal position.
pub type HorizontalPosition = LengthOrPercentage;
pub type HorizontalPosition = LengthPercentage;
/// The computed value of a CSS vertical position.
pub type VerticalPosition = LengthOrPercentage;
pub type VerticalPosition = LengthPercentage;
impl Position {
/// `50% 50%`
#[inline]
pub fn center() -> Self {
Self::new(
LengthOrPercentage::new_percent(Percentage(0.5)),
LengthOrPercentage::new_percent(Percentage(0.5)),
LengthPercentage::new_percent(Percentage(0.5)),
LengthPercentage::new_percent(Percentage(0.5)),
)
}
/// `0% 0%`
#[inline]
pub fn zero() -> Self {
Self::new(LengthOrPercentage::zero(), LengthOrPercentage::zero())
Self::new(LengthPercentage::zero(), LengthPercentage::zero())
}
}

36
components/style/values/computed/svg.rs
View file

@ -6,7 +6,7 @@
use crate::values::computed::color::Color;
use crate::values::computed::url::ComputedUrl;
use crate::values::computed::{LengthOrPercentage, NonNegativeLengthOrPercentage};
use crate::values::computed::{LengthPercentage, NonNegativeLengthPercentage};
use crate::values::computed::{NonNegativeNumber, Number, Opacity};
use crate::values::generics::svg as generic;
use crate::values::RGBA;
@ -42,56 +42,56 @@ impl SVGPaint {
/// A value of <length> | <percentage> | <number> for stroke-dashoffset.
/// <https://www.w3.org/TR/SVG11/painting.html#StrokeProperties>
pub type SvgLengthOrPercentageOrNumber =
generic::SvgLengthOrPercentageOrNumber<LengthOrPercentage, Number>;
pub type SvgLengthPercentageOrNumber =
generic::SvgLengthPercentageOrNumber<LengthPercentage, Number>;
/// <length> | <percentage> | <number> | context-value
pub type SVGLength = generic::SVGLength<SvgLengthOrPercentageOrNumber>;
pub type SVGLength = generic::SVGLength<SvgLengthPercentageOrNumber>;
impl SVGLength {
/// `0px`
pub fn zero() -> Self {
generic::SVGLength::Length(generic::SvgLengthOrPercentageOrNumber::LengthOrPercentage(
LengthOrPercentage::zero(),
generic::SVGLength::Length(generic::SvgLengthPercentageOrNumber::LengthPercentage(
LengthPercentage::zero(),
))
}
}
/// A value of <length> | <percentage> | <number> for stroke-width/stroke-dasharray.
/// <https://www.w3.org/TR/SVG11/painting.html#StrokeProperties>
pub type NonNegativeSvgLengthOrPercentageOrNumber =
generic::SvgLengthOrPercentageOrNumber<NonNegativeLengthOrPercentage, NonNegativeNumber>;
pub type NonNegativeSvgLengthPercentageOrNumber =
generic::SvgLengthPercentageOrNumber<NonNegativeLengthPercentage, NonNegativeNumber>;
// FIXME(emilio): This is really hacky, and can go away with a bit of work on
// the clone_stroke_width code in gecko.mako.rs.
impl Into<NonNegativeSvgLengthOrPercentageOrNumber> for SvgLengthOrPercentageOrNumber {
fn into(self) -> NonNegativeSvgLengthOrPercentageOrNumber {
impl Into<NonNegativeSvgLengthPercentageOrNumber> for SvgLengthPercentageOrNumber {
fn into(self) -> NonNegativeSvgLengthPercentageOrNumber {
match self {
generic::SvgLengthOrPercentageOrNumber::LengthOrPercentage(lop) => {
generic::SvgLengthOrPercentageOrNumber::LengthOrPercentage(lop.into())
generic::SvgLengthPercentageOrNumber::LengthPercentage(lop) => {
generic::SvgLengthPercentageOrNumber::LengthPercentage(lop.into())
},
generic::SvgLengthOrPercentageOrNumber::Number(num) => {
generic::SvgLengthOrPercentageOrNumber::Number(num.into())
generic::SvgLengthPercentageOrNumber::Number(num) => {
generic::SvgLengthPercentageOrNumber::Number(num.into())
},
}
}
}
/// An non-negative wrapper of SVGLength.
pub type SVGWidth = generic::SVGLength<NonNegativeSvgLengthOrPercentageOrNumber>;
pub type SVGWidth = generic::SVGLength<NonNegativeSvgLengthPercentageOrNumber>;
impl SVGWidth {
/// `1px`.
pub fn one() -> Self {
use crate::values::generics::NonNegative;
generic::SVGLength::Length(generic::SvgLengthOrPercentageOrNumber::LengthOrPercentage(
NonNegative(LengthOrPercentage::one()),
generic::SVGLength::Length(generic::SvgLengthPercentageOrNumber::LengthPercentage(
NonNegative(LengthPercentage::one()),
))
}
}
/// [ <length> | <percentage> | <number> ]# | context-value
pub type SVGStrokeDashArray = generic::SVGStrokeDashArray<NonNegativeSvgLengthOrPercentageOrNumber>;
pub type SVGStrokeDashArray = generic::SVGStrokeDashArray<NonNegativeSvgLengthPercentageOrNumber>;
impl Default for SVGStrokeDashArray {
fn default() -> Self {

4
components/style/values/computed/text.rs
View file

@ -6,7 +6,7 @@
#[cfg(feature = "servo")]
use crate::properties::StyleBuilder;
use crate::values::computed::length::{Length, LengthOrPercentage};
use crate::values::computed::length::{Length, LengthPercentage};
use crate::values::computed::{NonNegativeLength, NonNegativeNumber};
use crate::values::generics::text::InitialLetter as GenericInitialLetter;
use crate::values::generics::text::LineHeight as GenericLineHeight;
@ -29,7 +29,7 @@ pub type InitialLetter = GenericInitialLetter<CSSFloat, CSSInteger>;
pub type LetterSpacing = Spacing<Length>;
/// A computed value for the `word-spacing` property.
pub type WordSpacing = Spacing<LengthOrPercentage>;
pub type WordSpacing = Spacing<LengthPercentage>;
/// A computed value for the `line-height` property.
pub type LineHeight = GenericLineHeight<NonNegativeNumber, NonNegativeLength>;

20
components/style/values/computed/transform.rs
View file

@ -7,7 +7,7 @@
use super::CSSFloat;
use crate::values::animated::transform::{Perspective, Scale3D, Translate3D};
use crate::values::animated::ToAnimatedZero;
use crate::values::computed::{Angle, Integer, Length, LengthOrPercentage, Number, Percentage};
use crate::values::computed::{Angle, Integer, Length, LengthPercentage, Number, Percentage};
use crate::values::generics::transform as generic;
use euclid::{Transform3D, Vector3D};
use num_traits::Zero;
@ -16,12 +16,12 @@ pub use crate::values::generics::transform::TransformStyle;
/// A single operation in a computed CSS `transform`
pub type TransformOperation =
generic::TransformOperation<Angle, Number, Length, Integer, LengthOrPercentage>;
generic::TransformOperation<Angle, Number, Length, Integer, LengthPercentage>;
/// A computed CSS `transform`
pub type Transform = generic::Transform<TransformOperation>;
/// The computed value of a CSS `<transform-origin>`
pub type TransformOrigin = generic::TransformOrigin<LengthOrPercentage, LengthOrPercentage, Length>;
pub type TransformOrigin = generic::TransformOrigin<LengthPercentage, LengthPercentage, Length>;
/// A vector to represent the direction vector (rotate axis) for Rotate3D.
pub type DirectionVector = Vector3D<CSSFloat>;
@ -31,8 +31,8 @@ impl TransformOrigin {
#[inline]
pub fn initial_value() -> Self {
Self::new(
LengthOrPercentage::new_percent(Percentage(0.5)),
LengthOrPercentage::new_percent(Percentage(0.5)),
LengthPercentage::new_percent(Percentage(0.5)),
LengthPercentage::new_percent(Percentage(0.5)),
Length::new(0.),
)
}
@ -374,7 +374,7 @@ impl TransformOperation {
generic::TransformOperation::Translate(ref x, None) => {
generic::TransformOperation::Translate3D(
x.clone(),
LengthOrPercentage::zero(),
LengthPercentage::zero(),
Length::zero(),
)
},
@ -383,15 +383,15 @@ impl TransformOperation {
},
generic::TransformOperation::TranslateY(ref y) => {
generic::TransformOperation::Translate3D(
LengthOrPercentage::zero(),
LengthPercentage::zero(),
y.clone(),
Length::zero(),
)
},
generic::TransformOperation::TranslateZ(ref z) => {
generic::TransformOperation::Translate3D(
LengthOrPercentage::zero(),
LengthOrPercentage::zero(),
LengthPercentage::zero(),
LengthPercentage::zero(),
z.clone(),
)
},
@ -576,7 +576,7 @@ impl Rotate {
}
/// A computed CSS `translate`
pub type Translate = generic::Translate<LengthOrPercentage, Length>;
pub type Translate = generic::Translate<LengthPercentage, Length>;
impl Translate {
/// Convert TransformOperation to Translate.

10
components/style/values/generics/background.rs
View file

@ -22,13 +22,13 @@ use style_traits::{CssWriter, ToCss};
ToAnimatedZero,
ToComputedValue,
)]
pub enum BackgroundSize<LengthOrPercentageOrAuto> {
pub enum BackgroundSize<LengthPercentageOrAuto> {
/// `<width> <height>`
Explicit {
/// Explicit width.
width: LengthOrPercentageOrAuto,
width: LengthPercentageOrAuto,
/// Explicit height.
height: LengthOrPercentageOrAuto,
height: LengthPercentageOrAuto,
},
/// `cover`
#[animation(error)]
@ -38,9 +38,9 @@ pub enum BackgroundSize<LengthOrPercentageOrAuto> {
Contain,
}
impl<LengthOrPercentageOrAuto> ToCss for BackgroundSize<LengthOrPercentageOrAuto>
impl<LengthPercentageOrAuto> ToCss for BackgroundSize<LengthPercentageOrAuto>
where
LengthOrPercentageOrAuto: ToCss + IsAuto,
LengthPercentageOrAuto: ToCss + IsAuto,
{
fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
where

36
components/style/values/generics/basic_shape.rs
View file

@ -104,11 +104,11 @@ pub enum ShapeSource<BasicShape, ReferenceBox, ImageOrUrl> {
ToComputedValue,
ToCss,
)]
pub enum BasicShape<H, V, LengthOrPercentage, NonNegativeLengthOrPercentage> {
Inset(#[css(field_bound)] InsetRect<LengthOrPercentage, NonNegativeLengthOrPercentage>),
Circle(#[css(field_bound)] Circle<H, V, NonNegativeLengthOrPercentage>),
Ellipse(#[css(field_bound)] Ellipse<H, V, NonNegativeLengthOrPercentage>),
Polygon(Polygon<LengthOrPercentage>),
pub enum BasicShape<H, V, LengthPercentage, NonNegativeLengthPercentage> {
Inset(#[css(field_bound)] InsetRect<LengthPercentage, NonNegativeLengthPercentage>),
Circle(#[css(field_bound)] Circle<H, V, NonNegativeLengthPercentage>),
Ellipse(#[css(field_bound)] Ellipse<H, V, NonNegativeLengthPercentage>),
Polygon(Polygon<LengthPercentage>),
}
/// <https://drafts.csswg.org/css-shapes/#funcdef-inset>
@ -125,9 +125,9 @@ pub enum BasicShape<H, V, LengthOrPercentage, NonNegativeLengthOrPercentage> {
ToAnimatedValue,
ToComputedValue,
)]
pub struct InsetRect<LengthOrPercentage, NonNegativeLengthOrPercentage> {
pub rect: Rect<LengthOrPercentage>,
pub round: Option<BorderRadius<NonNegativeLengthOrPercentage>>,
pub struct InsetRect<LengthPercentage, NonNegativeLengthPercentage> {
pub rect: Rect<LengthPercentage>,
pub round: Option<BorderRadius<NonNegativeLengthPercentage>>,
}
/// <https://drafts.csswg.org/css-shapes/#funcdef-circle>
@ -145,9 +145,9 @@ pub struct InsetRect<LengthOrPercentage, NonNegativeLengthOrPercentage> {
ToAnimatedValue,
ToComputedValue,
)]
pub struct Circle<H, V, NonNegativeLengthOrPercentage> {
pub struct Circle<H, V, NonNegativeLengthPercentage> {
pub position: Position<H, V>,
pub radius: ShapeRadius<NonNegativeLengthOrPercentage>,
pub radius: ShapeRadius<NonNegativeLengthPercentage>,
}
/// <https://drafts.csswg.org/css-shapes/#funcdef-ellipse>
@ -165,10 +165,10 @@ pub struct Circle<H, V, NonNegativeLengthOrPercentage> {
ToAnimatedValue,
ToComputedValue,
)]
pub struct Ellipse<H, V, NonNegativeLengthOrPercentage> {
pub struct Ellipse<H, V, NonNegativeLengthPercentage> {
pub position: Position<H, V>,
pub semiaxis_x: ShapeRadius<NonNegativeLengthOrPercentage>,
pub semiaxis_y: ShapeRadius<NonNegativeLengthOrPercentage>,
pub semiaxis_x: ShapeRadius<NonNegativeLengthPercentage>,
pub semiaxis_y: ShapeRadius<NonNegativeLengthPercentage>,
}
/// <https://drafts.csswg.org/css-shapes/#typedef-shape-radius>
@ -186,8 +186,8 @@ pub struct Ellipse<H, V, NonNegativeLengthOrPercentage> {
ToComputedValue,
ToCss,
)]
pub enum ShapeRadius<NonNegativeLengthOrPercentage> {
Length(NonNegativeLengthOrPercentage),
pub enum ShapeRadius<NonNegativeLengthPercentage> {
Length(NonNegativeLengthPercentage),
#[animation(error)]
ClosestSide,
#[animation(error)]
@ -208,13 +208,13 @@ pub enum ShapeRadius<NonNegativeLengthOrPercentage> {
ToComputedValue,
ToCss,
)]
pub struct Polygon<LengthOrPercentage> {
pub struct Polygon<LengthPercentage> {
/// The filling rule for a polygon.
#[css(skip_if = "fill_is_default")]
pub fill: FillRule,
/// A collection of (x, y) coordinates to draw the polygon.
#[css(iterable)]
pub coordinates: Vec<PolygonCoord<LengthOrPercentage>>,
pub coordinates: Vec<PolygonCoord<LengthPercentage>>,
}
/// Coordinates for Polygon.
@ -228,7 +228,7 @@ pub struct Polygon<LengthOrPercentage> {
ToComputedValue,
ToCss,
)]
pub struct PolygonCoord<LengthOrPercentage>(pub LengthOrPercentage, pub LengthOrPercentage);
pub struct PolygonCoord<LengthPercentage>(pub LengthPercentage, pub LengthPercentage);
// https://drafts.csswg.org/css-shapes/#typedef-fill-rule
// NOTE: Basic shapes spec says that these are the only two values, however

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

@ -13,9 +13,9 @@ use style_traits::{CssWriter, ToCss};
#[derive(
Clone, Copy, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToComputedValue, ToCss,
)]
pub enum BorderImageSideWidth<LengthOrPercentage, Number> {
pub enum BorderImageSideWidth<LengthPercentage, Number> {
/// `<length-or-percentage>`
Length(LengthOrPercentage),
Length(LengthPercentage),
/// `<number>`
Number(Number),
/// `auto`
@ -98,15 +98,15 @@ impl<L> BorderSpacing<L> {
ToAnimatedValue,
ToComputedValue,
)]
pub struct BorderRadius<LengthOrPercentage> {
pub struct BorderRadius<LengthPercentage> {
/// The top left radius.
pub top_left: BorderCornerRadius<LengthOrPercentage>,
pub top_left: BorderCornerRadius<LengthPercentage>,
/// The top right radius.
pub top_right: BorderCornerRadius<LengthOrPercentage>,
pub top_right: BorderCornerRadius<LengthPercentage>,
/// The bottom right radius.
pub bottom_right: BorderCornerRadius<LengthOrPercentage>,
pub bottom_right: BorderCornerRadius<LengthPercentage>,
/// The bottom left radius.
pub bottom_left: BorderCornerRadius<LengthOrPercentage>,
pub bottom_left: BorderCornerRadius<LengthPercentage>,
}
impl<L> BorderRadius<L> {

4
components/style/values/generics/box.rs
View file

@ -19,7 +19,7 @@ use crate::values::animated::ToAnimatedZero;
ToComputedValue,
ToCss,
)]
pub enum VerticalAlign<LengthOrPercentage> {
pub enum VerticalAlign<LengthPercentage> {
/// `baseline`
Baseline,
/// `sub`
@ -40,7 +40,7 @@ pub enum VerticalAlign<LengthOrPercentage> {
#[cfg(feature = "gecko")]
MozMiddleWithBaseline,
/// `<length-percentage>`
Length(LengthOrPercentage),
Length(LengthPercentage),
}
impl<L> VerticalAlign<L> {

4
components/style/values/generics/gecko.rs
View file

@ -8,12 +8,12 @@
/// A generic value for scroll snap points.
#[cfg_attr(feature = "gecko", derive(MallocSizeOf))]
#[derive(Clone, Copy, Debug, PartialEq, SpecifiedValueInfo, ToComputedValue, ToCss)]
pub enum ScrollSnapPoint<LengthOrPercentage> {
pub enum ScrollSnapPoint<LengthPercentage> {
/// `none`
None,
/// `repeat(<length-or-percentage>)`
#[css(function)]
Repeat(LengthOrPercentage),
Repeat(LengthPercentage),
}
impl<L> ScrollSnapPoint<L> {

12
components/style/values/generics/grid.rs
View file

@ -482,11 +482,11 @@ impl<L: Clone> TrackRepeat<L, specified::Integer> {
/// Track list values. Can be <track-size> or <track-repeat>
#[derive(Clone, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToComputedValue, ToCss)]
pub enum TrackListValue<LengthOrPercentage, Integer> {
pub enum TrackListValue<LengthPercentage, Integer> {
/// A <track-size> value.
TrackSize(TrackSize<LengthOrPercentage>),
TrackSize(TrackSize<LengthPercentage>),
/// A <track-repeat> value.
TrackRepeat(TrackRepeat<LengthOrPercentage, Integer>),
TrackRepeat(TrackRepeat<LengthPercentage, Integer>),
}
/// The type of a `<track-list>` as determined during parsing.
@ -515,7 +515,7 @@ pub enum TrackListType {
///
/// <https://drafts.csswg.org/css-grid/#typedef-track-list>
#[derive(Clone, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo)]
pub struct TrackList<LengthOrPercentage, Integer> {
pub struct TrackList<LengthPercentage, Integer> {
/// The type of this `<track-list>` (auto, explicit or general).
///
/// In order to avoid parsing the same value multiple times, this does a single traversal
@ -523,7 +523,7 @@ pub struct TrackList<LengthOrPercentage, Integer> {
#[css(skip)]
pub list_type: TrackListType,
/// A vector of `<track-size> | <track-repeat>` values.
pub values: Vec<TrackListValue<LengthOrPercentage, Integer>>,
pub values: Vec<TrackListValue<LengthPercentage, Integer>>,
/// `<line-names>` accompanying `<track-size> | <track-repeat>` values.
///
/// If there's no `<line-names>`, then it's represented by an empty vector.
@ -531,7 +531,7 @@ pub struct TrackList<LengthOrPercentage, Integer> {
/// length is always one value more than that of the `<track-size>`.
pub line_names: Box<[Box<[CustomIdent]>]>,
/// `<auto-repeat>` value. There can only be one `<auto-repeat>` in a TrackList.
pub auto_repeat: Option<TrackRepeat<LengthOrPercentage, Integer>>,
pub auto_repeat: Option<TrackRepeat<LengthPercentage, Integer>>,
}
impl<L: ToCss, I: ToCss> ToCss for TrackList<L, I> {

28
components/style/values/generics/image.rs
View file

@ -37,11 +37,11 @@ pub enum Image<Gradient, MozImageRect, ImageUrl> {
/// A CSS gradient.
/// <https://drafts.csswg.org/css-images/#gradients>
#[derive(Clone, Debug, MallocSizeOf, PartialEq, ToComputedValue)]
pub struct Gradient<LineDirection, Length, LengthOrPercentage, Position, Color, Angle> {
pub struct Gradient<LineDirection, Length, LengthPercentage, Position, Color, Angle> {
/// Gradients can be linear or radial.
pub kind: GradientKind<LineDirection, Length, LengthOrPercentage, Position, Angle>,
pub kind: GradientKind<LineDirection, Length, LengthPercentage, Position, Angle>,
/// The color stops and interpolation hints.
pub items: Vec<GradientItem<Color, LengthOrPercentage>>,
pub items: Vec<GradientItem<Color, LengthPercentage>>,
/// True if this is a repeating gradient.
pub repeating: bool,
/// Compatibility mode.
@ -61,12 +61,12 @@ pub enum CompatMode {
/// A gradient kind.
#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, ToComputedValue)]
pub enum GradientKind<LineDirection, Length, LengthOrPercentage, Position, Angle> {
pub enum GradientKind<LineDirection, Length, LengthPercentage, Position, Angle> {
/// A linear gradient.
Linear(LineDirection),
/// A radial gradient.
Radial(
EndingShape<Length, LengthOrPercentage>,
EndingShape<Length, LengthPercentage>,
Position,
Option<Angle>,
),
@ -74,11 +74,11 @@ pub enum GradientKind<LineDirection, Length, LengthOrPercentage, Position, Angle
/// A radial gradient's ending shape.
#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, ToComputedValue, ToCss)]
pub enum EndingShape<Length, LengthOrPercentage> {
pub enum EndingShape<Length, LengthPercentage> {
/// A circular gradient.
Circle(Circle<Length>),
/// An elliptic gradient.
Ellipse(Ellipse<LengthOrPercentage>),
Ellipse(Ellipse<LengthPercentage>),
}
/// A circle shape.
@ -92,9 +92,9 @@ pub enum Circle<Length> {
/// An ellipse shape.
#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, ToComputedValue, ToCss)]
pub enum Ellipse<LengthOrPercentage> {
pub enum Ellipse<LengthPercentage> {
/// An ellipse pair of radii.
Radii(LengthOrPercentage, LengthOrPercentage),
Radii(LengthPercentage, LengthPercentage),
/// An ellipse extent.
Extent(ShapeExtent),
}
@ -115,21 +115,21 @@ pub enum ShapeExtent {
/// A gradient item.
/// <https://drafts.csswg.org/css-images-4/#color-stop-syntax>
#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, ToComputedValue, ToCss)]
pub enum GradientItem<Color, LengthOrPercentage> {
pub enum GradientItem<Color, LengthPercentage> {
/// A color stop.
ColorStop(ColorStop<Color, LengthOrPercentage>),
ColorStop(ColorStop<Color, LengthPercentage>),
/// An interpolation hint.
InterpolationHint(LengthOrPercentage),
InterpolationHint(LengthPercentage),
}
/// A color stop.
/// <https://drafts.csswg.org/css-images/#typedef-color-stop-list>
#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, ToComputedValue, ToCss)]
pub struct ColorStop<Color, LengthOrPercentage> {
pub struct ColorStop<Color, LengthPercentage> {
/// The color of this stop.
pub color: Color,
/// The position of this stop.
pub position: Option<LengthOrPercentage>,
pub position: Option<LengthPercentage>,
}
/// Specified values for a paint worklet.

8
components/style/values/generics/length.rs
View file

@ -26,8 +26,8 @@ use crate::values::computed::ExtremumLength;
ToComputedValue,
ToCss,
)]
pub enum MozLength<LengthOrPercentageOrAuto> {
LengthOrPercentageOrAuto(LengthOrPercentageOrAuto),
pub enum MozLength<LengthPercentageOrAuto> {
LengthPercentageOrAuto(LengthPercentageOrAuto),
#[animation(error)]
ExtremumLength(ExtremumLength),
}
@ -47,8 +47,8 @@ pub enum MozLength<LengthOrPercentageOrAuto> {
ToComputedValue,
ToCss,
)]
pub enum MaxLength<LengthOrPercentageOrNone> {
LengthOrPercentageOrNone(LengthOrPercentageOrNone),
pub enum MaxLength<LengthPercentageOrNone> {
LengthPercentageOrNone(LengthPercentageOrNone),
#[animation(error)]
ExtremumLength(ExtremumLength),
}

16
components/style/values/generics/svg.rs
View file

@ -142,28 +142,28 @@ impl<ColorType: Parse, UrlPaintServer: Parse> Parse for SVGPaint<ColorType, UrlP
ToComputedValue,
ToCss,
)]
pub enum SvgLengthOrPercentageOrNumber<LengthOrPercentage, Number> {
pub enum SvgLengthPercentageOrNumber<LengthPercentage, Number> {
/// <length> | <percentage>
LengthOrPercentage(LengthOrPercentage),
LengthPercentage(LengthPercentage),
/// <number>
Number(Number),
}
/// Parsing the SvgLengthOrPercentageOrNumber. At first, we need to parse number
/// Parsing the SvgLengthPercentageOrNumber. At first, we need to parse number
/// since prevent converting to the length.
impl<LengthOrPercentageType: Parse, NumberType: Parse> Parse
for SvgLengthOrPercentageOrNumber<LengthOrPercentageType, NumberType>
impl<LengthPercentageType: Parse, NumberType: Parse> Parse
for SvgLengthPercentageOrNumber<LengthPercentageType, NumberType>
{
fn parse<'i, 't>(
context: &ParserContext,
input: &mut Parser<'i, 't>,
) -> Result<Self, ParseError<'i>> {
if let Ok(num) = input.try(|i| NumberType::parse(context, i)) {
return Ok(SvgLengthOrPercentageOrNumber::Number(num));
return Ok(SvgLengthPercentageOrNumber::Number(num));
}
let lop = LengthOrPercentageType::parse(context, input)?;
Ok(SvgLengthOrPercentageOrNumber::LengthOrPercentage(lop))
let lop = LengthPercentageType::parse(context, input)?;
Ok(SvgLengthPercentageOrNumber::LengthPercentage(lop))
}
}

4
components/style/values/generics/text.rs
View file

@ -123,7 +123,7 @@ impl<V> ToAnimatedZero for Spacing<V> {
ToAnimatedValue,
ToCss,
)]
pub enum LineHeight<Number, LengthOrPercentage> {
pub enum LineHeight<Number, LengthPercentage> {
/// `normal`
Normal,
/// `-moz-block-height`
@ -132,7 +132,7 @@ pub enum LineHeight<Number, LengthOrPercentage> {
/// `<number>`
Number(Number),
/// `<length-or-percentage>`
Length(LengthOrPercentage),
Length(LengthPercentage),
}
impl<N, L> ToAnimatedZero for LineHeight<N, L> {

40
components/style/values/generics/transform.rs
View file

@ -5,10 +5,10 @@
//! Generic types for CSS values that are related to transformations.
use crate::values::computed::length::Length as ComputedLength;
use crate::values::computed::length::LengthOrPercentage as ComputedLengthOrPercentage;
use crate::values::computed::length::LengthPercentage as ComputedLengthPercentage;
use crate::values::specified::angle::Angle as SpecifiedAngle;
use crate::values::specified::length::Length as SpecifiedLength;
use crate::values::specified::length::LengthOrPercentage as SpecifiedLengthOrPercentage;
use crate::values::specified::length::LengthPercentage as SpecifiedLengthPercentage;
use crate::values::{computed, CSSFloat};
use app_units::Au;
use euclid::{self, Rect, Transform3D};
@ -105,7 +105,7 @@ impl<H, V, D> TransformOrigin<H, V, D> {
#[derive(Clone, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToComputedValue, ToCss)]
/// A single operation in the list of a `transform` value
pub enum TransformOperation<Angle, Number, Length, Integer, LengthOrPercentage> {
pub enum TransformOperation<Angle, Number, Length, Integer, LengthPercentage> {
/// Represents a 2D 2x3 matrix.
Matrix(Matrix<Number>),
/// Represents a 3D 4x4 matrix.
@ -125,19 +125,19 @@ pub enum TransformOperation<Angle, Number, Length, Integer, LengthOrPercentage>
SkewY(Angle),
/// translate(x, y) or translate(x)
#[css(comma, function)]
Translate(LengthOrPercentage, Option<LengthOrPercentage>),
Translate(LengthPercentage, Option<LengthPercentage>),
/// translateX(x)
#[css(function = "translateX")]
TranslateX(LengthOrPercentage),
TranslateX(LengthPercentage),
/// translateY(y)
#[css(function = "translateY")]
TranslateY(LengthOrPercentage),
TranslateY(LengthPercentage),
/// translateZ(z)
#[css(function = "translateZ")]
TranslateZ(Length),
/// translate3d(x, y, z)
#[css(comma, function = "translate3d")]
Translate3D(LengthOrPercentage, LengthOrPercentage, Length),
Translate3D(LengthPercentage, LengthPercentage, Length),
/// A 2D scaling factor.
///
/// `scale(2)` is parsed as `Scale(Number::new(2.0), None)` and is equivalent to
@ -192,8 +192,8 @@ pub enum TransformOperation<Angle, Number, Length, Integer, LengthOrPercentage>
#[css(comma, function = "interpolatematrix")]
InterpolateMatrix {
from_list:
Transform<TransformOperation<Angle, Number, Length, Integer, LengthOrPercentage>>,
to_list: Transform<TransformOperation<Angle, Number, Length, Integer, LengthOrPercentage>>,
Transform<TransformOperation<Angle, Number, Length, Integer, LengthPercentage>>,
to_list: Transform<TransformOperation<Angle, Number, Length, Integer, LengthPercentage>>,
progress: computed::Percentage,
},
/// A intermediate type for accumulation of mismatched transform lists.
@ -201,8 +201,8 @@ pub enum TransformOperation<Angle, Number, Length, Integer, LengthOrPercentage>
#[css(comma, function = "accumulatematrix")]
AccumulateMatrix {
from_list:
Transform<TransformOperation<Angle, Number, Length, Integer, LengthOrPercentage>>,
to_list: Transform<TransformOperation<Angle, Number, Length, Integer, LengthOrPercentage>>,
Transform<TransformOperation<Angle, Number, Length, Integer, LengthPercentage>>,
to_list: Transform<TransformOperation<Angle, Number, Length, Integer, LengthPercentage>>,
count: Integer,
},
}
@ -211,8 +211,8 @@ pub enum TransformOperation<Angle, Number, Length, Integer, LengthOrPercentage>
/// A value of the `transform` property
pub struct Transform<T>(#[css(if_empty = "none", iterable)] pub Vec<T>);
impl<Angle, Number, Length, Integer, LengthOrPercentage>
TransformOperation<Angle, Number, Length, Integer, LengthOrPercentage>
impl<Angle, Number, Length, Integer, LengthPercentage>
TransformOperation<Angle, Number, Length, Integer, LengthPercentage>
{
/// Check if it is any rotate function.
pub fn is_rotate(&self) -> bool {
@ -263,13 +263,13 @@ impl ToAbsoluteLength for SpecifiedLength {
}
}
impl ToAbsoluteLength for SpecifiedLengthOrPercentage {
impl ToAbsoluteLength for SpecifiedLengthPercentage {
// This returns Err(()) if there is any relative length or percentage. We use this when
// parsing a transform list of DOMMatrix because we want to return a DOM Exception
// if there is relative length.
#[inline]
fn to_pixel_length(&self, _containing_len: Option<Au>) -> Result<CSSFloat, ()> {
use self::SpecifiedLengthOrPercentage::*;
use self::SpecifiedLengthPercentage::*;
match *self {
Length(len) => len.to_computed_pixel_length_without_context(),
Calc(ref calc) => calc.to_computed_pixel_length_without_context(),
@ -285,7 +285,7 @@ impl ToAbsoluteLength for ComputedLength {
}
}
impl ToAbsoluteLength for ComputedLengthOrPercentage {
impl ToAbsoluteLength for ComputedLengthPercentage {
#[inline]
fn to_pixel_length(&self, containing_len: Option<Au>) -> Result<CSSFloat, ()> {
match containing_len {
@ -633,18 +633,18 @@ impl<Number: ToCss + PartialEq> ToCss for Scale<Number> {
/// A value of the `Translate` property
///
/// <https://drafts.csswg.org/css-transforms-2/#individual-transforms>
pub enum Translate<LengthOrPercentage, Length> {
pub enum Translate<LengthPercentage, Length> {
/// 'none'
None,
/// '<length-percentage>' or '<length-percentage> <length-percentage>'
Translate(LengthOrPercentage, LengthOrPercentage),
Translate(LengthPercentage, LengthPercentage),
/// '<length-percentage> <length-percentage> <length>'
Translate3D(LengthOrPercentage, LengthOrPercentage, Length),
Translate3D(LengthPercentage, LengthPercentage, Length),
}
/// A trait to check if this is a zero length.
/// An alternative way is use num_traits::Zero. However, in order to implement num_traits::Zero,
/// we also have to implement Add, which may be complicated for LengthOrPercentage::Calc.
/// we also have to implement Add, which may be complicated for LengthPercentage::Calc.
/// We could do this if other types also need it. If so, we could drop this trait.
pub trait IsZeroLength {
/// Returns true if this is a zero length.

14
components/style/values/specified/background.rs
View file

@ -6,24 +6,24 @@
use crate::parser::{Parse, ParserContext};
use crate::values::generics::background::BackgroundSize as GenericBackgroundSize;
use crate::values::specified::length::NonNegativeLengthOrPercentageOrAuto;
use crate::values::specified::length::NonNegativeLengthPercentageOrAuto;
use cssparser::Parser;
use selectors::parser::SelectorParseErrorKind;
use std::fmt::{self, Write};
use style_traits::{CssWriter, ParseError, ToCss};
/// A specified value for the `background-size` property.
pub type BackgroundSize = GenericBackgroundSize<NonNegativeLengthOrPercentageOrAuto>;
pub type BackgroundSize = GenericBackgroundSize<NonNegativeLengthPercentageOrAuto>;
impl Parse for BackgroundSize {
fn parse<'i, 't>(
context: &ParserContext,
input: &mut Parser<'i, 't>,
) -> Result<Self, ParseError<'i>> {
if let Ok(width) = input.try(|i| NonNegativeLengthOrPercentageOrAuto::parse(context, i)) {
if let Ok(width) = input.try(|i| NonNegativeLengthPercentageOrAuto::parse(context, i)) {
let height = input
.try(|i| NonNegativeLengthOrPercentageOrAuto::parse(context, i))
.unwrap_or(NonNegativeLengthOrPercentageOrAuto::auto());
.try(|i| NonNegativeLengthPercentageOrAuto::parse(context, i))
.unwrap_or(NonNegativeLengthPercentageOrAuto::auto());
return Ok(GenericBackgroundSize::Explicit { width, height });
}
Ok(try_match_ident_ignore_ascii_case! { input,
@ -37,8 +37,8 @@ impl BackgroundSize {
/// Returns `auto auto`.
pub fn auto() -> Self {
GenericBackgroundSize::Explicit {
width: NonNegativeLengthOrPercentageOrAuto::auto(),
height: NonNegativeLengthOrPercentageOrAuto::auto(),
width: NonNegativeLengthPercentageOrAuto::auto(),
height: NonNegativeLengthPercentageOrAuto::auto(),
}
}
}

24
components/style/values/specified/basic_shape.rs
View file

@ -17,7 +17,7 @@ use crate::values::specified::image::Image;
use crate::values::specified::position::{HorizontalPosition, Position, VerticalPosition};
use crate::values::specified::url::SpecifiedUrl;
use crate::values::specified::SVGPathData;
use crate::values::specified::{LengthOrPercentage, NonNegativeLengthOrPercentage};
use crate::values::specified::{LengthPercentage, NonNegativeLengthPercentage};
use cssparser::Parser;
use std::fmt::{self, Write};
use style_traits::{CssWriter, ParseError, StyleParseErrorKind, ToCss};
@ -35,26 +35,26 @@ pub type FloatAreaShape = generic::FloatAreaShape<BasicShape, Image>;
pub type BasicShape = generic::BasicShape<
HorizontalPosition,
VerticalPosition,
LengthOrPercentage,
NonNegativeLengthOrPercentage,
LengthPercentage,
NonNegativeLengthPercentage,
>;
/// The specified value of `inset()`
pub type InsetRect = generic::InsetRect<LengthOrPercentage, NonNegativeLengthOrPercentage>;
pub type InsetRect = generic::InsetRect<LengthPercentage, NonNegativeLengthPercentage>;
/// A specified circle.
pub type Circle =
generic::Circle<HorizontalPosition, VerticalPosition, NonNegativeLengthOrPercentage>;
generic::Circle<HorizontalPosition, VerticalPosition, NonNegativeLengthPercentage>;
/// A specified ellipse.
pub type Ellipse =
generic::Ellipse<HorizontalPosition, VerticalPosition, NonNegativeLengthOrPercentage>;
generic::Ellipse<HorizontalPosition, VerticalPosition, NonNegativeLengthPercentage>;
/// The specified value of `ShapeRadius`
pub type ShapeRadius = generic::ShapeRadius<NonNegativeLengthOrPercentage>;
pub type ShapeRadius = generic::ShapeRadius<NonNegativeLengthPercentage>;
/// The specified value of `Polygon`
pub type Polygon = generic::Polygon<LengthOrPercentage>;
pub type Polygon = generic::Polygon<LengthPercentage>;
#[cfg(feature = "gecko")]
fn is_clip_path_path_enabled(context: &ParserContext) -> bool {
@ -200,7 +200,7 @@ impl InsetRect {
context: &ParserContext,
input: &mut Parser<'i, 't>,
) -> Result<Self, ParseError<'i>> {
let rect = Rect::parse_with(context, input, LengthOrPercentage::parse)?;
let rect = Rect::parse_with(context, input, LengthPercentage::parse)?;
let round = if input.try(|i| i.expect_ident_matching("round")).is_ok() {
Some(BorderRadius::parse(context, input)?)
} else {
@ -316,7 +316,7 @@ impl Parse for ShapeRadius {
context: &ParserContext,
input: &mut Parser<'i, 't>,
) -> Result<Self, ParseError<'i>> {
if let Ok(lop) = input.try(|i| NonNegativeLengthOrPercentage::parse(context, i)) {
if let Ok(lop) = input.try(|i| NonNegativeLengthPercentage::parse(context, i)) {
return Ok(generic::ShapeRadius::Length(lop));
}
@ -353,8 +353,8 @@ impl Polygon {
let buf = input.parse_comma_separated(|i| {
Ok(PolygonCoord(
LengthOrPercentage::parse(context, i)?,
LengthOrPercentage::parse(context, i)?,
LengthPercentage::parse(context, i)?,
LengthPercentage::parse(context, i)?,
))
})?;

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

@ -13,7 +13,7 @@ use crate::values::generics::border::BorderRadius as GenericBorderRadius;
use crate::values::generics::border::BorderSpacing as GenericBorderSpacing;
use crate::values::generics::rect::Rect;
use crate::values::generics::size::Size;
use crate::values::specified::length::{NonNegativeLength, NonNegativeLengthOrPercentage};
use crate::values::specified::length::{NonNegativeLength, NonNegativeLengthPercentage};
use crate::values::specified::{AllowQuirks, NonNegativeNumber, NonNegativeNumberOrPercentage};
use cssparser::Parser;
use std::fmt::{self, Write};
@ -79,16 +79,16 @@ pub type BorderImageWidth = Rect<BorderImageSideWidth>;
/// A specified value for a single side of a `border-image-width` property.
pub type BorderImageSideWidth =
GenericBorderImageSideWidth<NonNegativeLengthOrPercentage, NonNegativeNumber>;
GenericBorderImageSideWidth<NonNegativeLengthPercentage, NonNegativeNumber>;
/// A specified value for the `border-image-slice` property.
pub type BorderImageSlice = GenericBorderImageSlice<NonNegativeNumberOrPercentage>;
/// A specified value for the `border-radius` property.
pub type BorderRadius = GenericBorderRadius<NonNegativeLengthOrPercentage>;
pub type BorderRadius = GenericBorderRadius<NonNegativeLengthPercentage>;
/// A specified value for the `border-*-radius` longhand properties.
pub type BorderCornerRadius = GenericBorderCornerRadius<NonNegativeLengthOrPercentage>;
pub type BorderCornerRadius = GenericBorderCornerRadius<NonNegativeLengthPercentage>;
/// A specified value for the `border-spacing` longhand properties.
pub type BorderSpacing = GenericBorderSpacing<NonNegativeLength>;
@ -178,7 +178,7 @@ impl Parse for BorderImageSideWidth {
return Ok(GenericBorderImageSideWidth::Auto);
}
if let Ok(len) = input.try(|i| NonNegativeLengthOrPercentage::parse(context, i)) {
if let Ok(len) = input.try(|i| NonNegativeLengthPercentage::parse(context, i)) {
return Ok(GenericBorderImageSideWidth::Length(len));
}
@ -206,9 +206,9 @@ impl Parse for BorderRadius {
context: &ParserContext,
input: &mut Parser<'i, 't>,
) -> Result<Self, ParseError<'i>> {
let widths = Rect::parse_with(context, input, NonNegativeLengthOrPercentage::parse)?;
let widths = Rect::parse_with(context, input, NonNegativeLengthPercentage::parse)?;
let heights = if input.try(|i| i.expect_delim('/')).is_ok() {
Rect::parse_with(context, input, NonNegativeLengthOrPercentage::parse)?
Rect::parse_with(context, input, NonNegativeLengthPercentage::parse)?
} else {
widths.clone()
};
@ -227,7 +227,7 @@ impl Parse for BorderCornerRadius {
context: &ParserContext,
input: &mut Parser<'i, 't>,
) -> Result<Self, ParseError<'i>> {
Size::parse_with(context, input, NonNegativeLengthOrPercentage::parse)
Size::parse_with(context, input, NonNegativeLengthPercentage::parse)
.map(GenericBorderCornerRadius)
}
}

6
components/style/values/specified/box.rs
View file

@ -11,7 +11,7 @@ use crate::properties::{PropertyId, ShorthandId};
use crate::values::generics::box_::AnimationIterationCount as GenericAnimationIterationCount;
use crate::values::generics::box_::Perspective as GenericPerspective;
use crate::values::generics::box_::VerticalAlign as GenericVerticalAlign;
use crate::values::specified::length::{LengthOrPercentage, NonNegativeLength};
use crate::values::specified::length::{LengthPercentage, NonNegativeLength};
use crate::values::specified::{AllowQuirks, Number};
use crate::values::{CustomIdent, KeyframesName};
use crate::Atom;
@ -271,7 +271,7 @@ impl Display {
}
/// A specified value for the `vertical-align` property.
pub type VerticalAlign = GenericVerticalAlign<LengthOrPercentage>;
pub type VerticalAlign = GenericVerticalAlign<LengthPercentage>;
impl Parse for VerticalAlign {
fn parse<'i, 't>(
@ -279,7 +279,7 @@ impl Parse for VerticalAlign {
input: &mut Parser<'i, 't>,
) -> Result<Self, ParseError<'i>> {
if let Ok(lop) =
input.try(|i| LengthOrPercentage::parse_quirky(context, i, AllowQuirks::Yes))
input.try(|i| LengthPercentage::parse_quirky(context, i, AllowQuirks::Yes))
{
return Ok(GenericVerticalAlign::Length(lop));
}

24
components/style/values/specified/calc.rs
View file

@ -52,7 +52,7 @@ pub enum CalcUnit {
/// `<percentage>`
Percentage,
/// `<length> | <percentage>`
LengthOrPercentage,
LengthPercentage,
/// `<angle>`
Angle,
/// `<time>`
@ -67,7 +67,7 @@ pub enum CalcUnit {
/// function work properly.
#[derive(Clone, Copy, Debug, Default, MallocSizeOf, PartialEq)]
#[allow(missing_docs)]
pub struct CalcLengthOrPercentage {
pub struct CalcLengthPercentage {
pub clamping_mode: AllowedNumericType,
pub absolute: Option<AbsoluteLength>,
pub vw: Option<CSSFloat>,
@ -81,7 +81,7 @@ pub struct CalcLengthOrPercentage {
pub percentage: Option<computed::Percentage>,
}
impl ToCss for CalcLengthOrPercentage {
impl ToCss for CalcLengthPercentage {
/// <https://drafts.csswg.org/css-values/#calc-serialize>
///
/// FIXME(emilio): Should this simplify away zeros?
@ -148,7 +148,7 @@ impl ToCss for CalcLengthOrPercentage {
}
}
impl SpecifiedValueInfo for CalcLengthOrPercentage {}
impl SpecifiedValueInfo for CalcLengthPercentage {}
impl CalcNode {
/// Tries to parse a single element in the expression, that is, a
@ -176,7 +176,7 @@ impl CalcNode {
&Token::Dimension {
value, ref unit, ..
},
CalcUnit::LengthOrPercentage,
CalcUnit::LengthPercentage,
) => {
return NoCalcLength::parse_dimension(context, value, unit)
.map(CalcNode::Length)
@ -202,7 +202,7 @@ impl CalcNode {
.map(CalcNode::Time)
.map_err(|()| location.new_custom_error(StyleParseErrorKind::UnspecifiedError));
},
(&Token::Percentage { unit_value, .. }, CalcUnit::LengthOrPercentage) |
(&Token::Percentage { unit_value, .. }, CalcUnit::LengthPercentage) |
(&Token::Percentage { unit_value, .. }, CalcUnit::Percentage) => {
return Ok(CalcNode::Percentage(unit_value));
},
@ -299,8 +299,8 @@ impl CalcNode {
fn to_length_or_percentage(
&self,
clamping_mode: AllowedNumericType,
) -> Result<CalcLengthOrPercentage, ()> {
let mut ret = CalcLengthOrPercentage {
) -> Result<CalcLengthPercentage, ()> {
let mut ret = CalcLengthPercentage {
clamping_mode: clamping_mode,
..Default::default()
};
@ -346,7 +346,7 @@ impl CalcNode {
/// (this allows adding and substracting into the return value).
fn add_length_or_percentage_to(
&self,
ret: &mut CalcLengthOrPercentage,
ret: &mut CalcLengthPercentage,
factor: CSSFloat,
) -> Result<(), ()> {
match *self {
@ -537,8 +537,8 @@ impl CalcNode {
context: &ParserContext,
input: &mut Parser<'i, 't>,
clamping_mode: AllowedNumericType,
) -> Result<CalcLengthOrPercentage, ParseError<'i>> {
Self::parse(context, input, CalcUnit::LengthOrPercentage)?
) -> Result<CalcLengthPercentage, ParseError<'i>> {
Self::parse(context, input, CalcUnit::LengthPercentage)?
.to_length_or_percentage(clamping_mode)
.map_err(|()| input.new_custom_error(StyleParseErrorKind::UnspecifiedError))
}
@ -558,7 +558,7 @@ impl CalcNode {
context: &ParserContext,
input: &mut Parser<'i, 't>,
clamping_mode: AllowedNumericType,
) -> Result<CalcLengthOrPercentage, ParseError<'i>> {
) -> Result<CalcLengthPercentage, ParseError<'i>> {
Self::parse(context, input, CalcUnit::Length)?
.to_length_or_percentage(clamping_mode)
.map_err(|()| input.new_custom_error(StyleParseErrorKind::UnspecifiedError))

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

@ -11,7 +11,7 @@ use style_traits::ParseError;
/// The `width` value type.
#[cfg(feature = "servo")]
pub type Width = crate::values::specified::NonNegativeLengthOrPercentageOrAuto;
pub type Width = crate::values::specified::NonNegativeLengthPercentageOrAuto;
/// The `width` value type.
#[cfg(feature = "gecko")]

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

@ -16,7 +16,7 @@ use crate::values::generics::font::{self as generics, FeatureTagValue, FontSetti
use crate::values::generics::font::{KeywordSize, VariationValue};
use crate::values::generics::NonNegative;
use crate::values::specified::length::{FontBaseSize, AU_PER_PT, AU_PER_PX};
use crate::values::specified::{AllowQuirks, Angle, Integer, LengthOrPercentage};
use crate::values::specified::{AllowQuirks, Angle, Integer, LengthPercentage};
use crate::values::specified::{NoCalcLength, Number, Percentage};
use crate::values::CustomIdent;
use crate::Atom;
@ -510,7 +510,7 @@ impl ToComputedValue for FontStretch {
/// A specified font-size value
pub enum FontSize {
/// A length; e.g. 10px.
Length(LengthOrPercentage),
Length(LengthPercentage),
/// A keyword value, along with a ratio and absolute offset.
/// The ratio in any specified keyword value
/// will be 1 (with offset 0), but we cascade keywordness even
@ -531,8 +531,8 @@ pub enum FontSize {
System(SystemFont),
}
impl From<LengthOrPercentage> for FontSize {
fn from(other: LengthOrPercentage) -> Self {
impl From<LengthPercentage> for FontSize {
fn from(other: LengthPercentage) -> Self {
FontSize::Length(other)
}
}
@ -863,7 +863,7 @@ impl FontSize {
};
let mut info = None;
let size = match *self {
FontSize::Length(LengthOrPercentage::Length(NoCalcLength::FontRelative(value))) => {
FontSize::Length(LengthPercentage::Length(NoCalcLength::FontRelative(value))) => {
if let FontRelativeLength::Em(em) = value {
// If the parent font was keyword-derived, this is too.
// Tack the em unit onto the factor
@ -871,22 +871,22 @@ impl FontSize {
}
value.to_computed_value(context, base_size).into()
},
FontSize::Length(LengthOrPercentage::Length(NoCalcLength::ServoCharacterWidth(
FontSize::Length(LengthPercentage::Length(NoCalcLength::ServoCharacterWidth(
value,
))) => value.to_computed_value(base_size.resolve(context)).into(),
FontSize::Length(LengthOrPercentage::Length(NoCalcLength::Absolute(ref l))) => {
FontSize::Length(LengthPercentage::Length(NoCalcLength::Absolute(ref l))) => {
context.maybe_zoom_text(l.to_computed_value(context).into())
},
FontSize::Length(LengthOrPercentage::Length(ref l)) => {
FontSize::Length(LengthPercentage::Length(ref l)) => {
l.to_computed_value(context).into()
},
FontSize::Length(LengthOrPercentage::Percentage(pc)) => {
FontSize::Length(LengthPercentage::Percentage(pc)) => {
// 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()
},
FontSize::Length(LengthOrPercentage::Calc(ref calc)) => {
FontSize::Length(LengthPercentage::Calc(ref calc)) => {
let parent = context.style().get_parent_font().clone_font_size();
// if we contain em/% units and the parent was keyword derived, this is too
// Extract the ratio/offset and compose it
@ -964,7 +964,7 @@ impl ToComputedValue for FontSize {
#[inline]
fn from_computed_value(computed: &computed::FontSize) -> Self {
FontSize::Length(LengthOrPercentage::Length(
FontSize::Length(LengthPercentage::Length(
ToComputedValue::from_computed_value(&computed.size.0),
))
}
@ -986,7 +986,7 @@ impl FontSize {
allow_quirks: AllowQuirks,
) -> Result<FontSize, ParseError<'i>> {
if let Ok(lop) =
input.try(|i| LengthOrPercentage::parse_non_negative_quirky(context, i, allow_quirks))
input.try(|i| LengthPercentage::parse_non_negative_quirky(context, i, allow_quirks))
{
return Ok(FontSize::Length(lop));
}

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

@ -11,14 +11,14 @@ use crate::values::computed;
use crate::values::computed::length::CSSPixelLength;
use crate::values::generics::gecko::ScrollSnapPoint as GenericScrollSnapPoint;
use crate::values::generics::rect::Rect;
use crate::values::specified::length::LengthOrPercentage;
use crate::values::specified::length::LengthPercentage;
use cssparser::{Parser, Token};
use std::fmt;
use style_traits::values::SequenceWriter;
use style_traits::{CssWriter, ParseError, StyleParseErrorKind, ToCss};
/// A specified type for scroll snap points.
pub type ScrollSnapPoint = GenericScrollSnapPoint<LengthOrPercentage>;
pub type ScrollSnapPoint = GenericScrollSnapPoint<LengthPercentage>;
impl Parse for ScrollSnapPoint {
fn parse<'i, 't>(
@ -30,7 +30,7 @@ impl Parse for ScrollSnapPoint {
}
input.expect_function_matching("repeat")?;
let length =
input.parse_nested_block(|i| LengthOrPercentage::parse_non_negative(context, i))?;
input.parse_nested_block(|i| LengthPercentage::parse_non_negative(context, i))?;
Ok(GenericScrollSnapPoint::Repeat(length))
}
}

26
components/style/values/specified/grid.rs
View file

@ -10,7 +10,7 @@ use crate::values::computed::{self, Context, ToComputedValue};
use crate::values::generics::grid::{GridTemplateComponent, RepeatCount, TrackBreadth};
use crate::values::generics::grid::{LineNameList, TrackKeyword, TrackRepeat, TrackSize};
use crate::values::generics::grid::{TrackList, TrackListType, TrackListValue};
use crate::values::specified::{Integer, LengthOrPercentage};
use crate::values::specified::{Integer, LengthPercentage};
use crate::values::{CSSFloat, CustomIdent};
use cssparser::{ParseError as CssParseError, Parser, Token};
use std::mem;
@ -27,12 +27,12 @@ pub fn parse_flex<'i, 't>(input: &mut Parser<'i, 't>) -> Result<CSSFloat, ParseE
}
}
impl Parse for TrackBreadth<LengthOrPercentage> {
impl Parse for TrackBreadth<LengthPercentage> {
fn parse<'i, 't>(
context: &ParserContext,
input: &mut Parser<'i, 't>,
) -> Result<Self, ParseError<'i>> {
if let Ok(lop) = input.try(|i| LengthOrPercentage::parse_non_negative(context, i)) {
if let Ok(lop) = input.try(|i| LengthPercentage::parse_non_negative(context, i)) {
return Ok(TrackBreadth::Breadth(lop));
}
@ -44,7 +44,7 @@ impl Parse for TrackBreadth<LengthOrPercentage> {
}
}
impl Parse for TrackSize<LengthOrPercentage> {
impl Parse for TrackSize<LengthPercentage> {
fn parse<'i, 't>(
context: &ParserContext,
input: &mut Parser<'i, 't>,
@ -56,7 +56,7 @@ impl Parse for TrackSize<LengthOrPercentage> {
if input.try(|i| i.expect_function_matching("minmax")).is_ok() {
return input.parse_nested_block(|input| {
let inflexible_breadth =
match input.try(|i| LengthOrPercentage::parse_non_negative(context, i)) {
match input.try(|i| LengthPercentage::parse_non_negative(context, i)) {
Ok(lop) => TrackBreadth::Breadth(lop),
Err(..) => {
let keyword = TrackKeyword::parse(input)?;
@ -74,7 +74,7 @@ impl Parse for TrackSize<LengthOrPercentage> {
input.expect_function_matching("fit-content")?;
let lop =
input.parse_nested_block(|i| LengthOrPercentage::parse_non_negative(context, i))?;
input.parse_nested_block(|i| LengthPercentage::parse_non_negative(context, i))?;
Ok(TrackSize::FitContent(lop))
}
}
@ -113,7 +113,7 @@ enum RepeatType {
Fixed,
}
impl TrackRepeat<LengthOrPercentage, Integer> {
impl TrackRepeat<LengthPercentage, Integer> {
fn parse_with_repeat_type<'i, 't>(
context: &ParserContext,
input: &mut Parser<'i, 't>,
@ -195,7 +195,7 @@ impl TrackRepeat<LengthOrPercentage, Integer> {
}
}
impl Parse for TrackList<LengthOrPercentage, Integer> {
impl Parse for TrackList<LengthPercentage, Integer> {
fn parse<'i, 't>(
context: &ParserContext,
input: &mut Parser<'i, 't>,
@ -293,8 +293,8 @@ impl Parse for TrackList<LengthOrPercentage, Integer> {
}
}
impl ToComputedValue for TrackList<LengthOrPercentage, Integer> {
type ComputedValue = TrackList<computed::LengthOrPercentage, computed::Integer>;
impl ToComputedValue for TrackList<LengthPercentage, Integer> {
type ComputedValue = TrackList<computed::LengthPercentage, computed::Integer>;
#[inline]
fn to_computed_value(&self, context: &Context) -> Self::ComputedValue {
@ -391,7 +391,7 @@ fn allow_grid_template_subgrids() -> bool {
false
}
impl Parse for GridTemplateComponent<LengthOrPercentage, Integer> {
impl Parse for GridTemplateComponent<LengthPercentage, Integer> {
// FIXME: Derive Parse (probably with None_)
fn parse<'i, 't>(
context: &ParserContext,
@ -405,8 +405,8 @@ impl Parse for GridTemplateComponent<LengthOrPercentage, Integer> {
}
}
impl GridTemplateComponent<LengthOrPercentage, Integer> {
/// Parses a `GridTemplateComponent<LengthOrPercentage>` except `none` keyword.
impl GridTemplateComponent<LengthPercentage, Integer> {
/// Parses a `GridTemplateComponent<LengthPercentage>` except `none` keyword.
pub fn parse_without_none<'i, 't>(
context: &ParserContext,
input: &mut Parser<'i, 't>,

44
components/style/values/specified/image.rs
View file

@ -16,7 +16,7 @@ use crate::values::generics::image::{self as generic, Circle, CompatMode, Ellips
use crate::values::generics::position::Position as GenericPosition;
use crate::values::specified::position::{LegacyPosition, Position, PositionComponent, Side, X, Y};
use crate::values::specified::url::SpecifiedImageUrl;
use crate::values::specified::{Angle, Color, Length, LengthOrPercentage};
use crate::values::specified::{Angle, Color, Length, LengthPercentage};
use crate::values::specified::{Number, NumberOrPercentage, Percentage};
use crate::values::{Either, None_};
use crate::Atom;
@ -54,13 +54,13 @@ pub type Image = generic::Image<Gradient, MozImageRect, SpecifiedImageUrl>;
/// <https://drafts.csswg.org/css-images/#gradients>
#[cfg(not(feature = "gecko"))]
pub type Gradient =
generic::Gradient<LineDirection, Length, LengthOrPercentage, Position, Color, Angle>;
generic::Gradient<LineDirection, Length, LengthPercentage, Position, Color, Angle>;
/// Specified values for a CSS gradient.
/// <https://drafts.csswg.org/css-images/#gradients>
#[cfg(feature = "gecko")]
pub type Gradient =
generic::Gradient<LineDirection, Length, LengthOrPercentage, GradientPosition, Color, Angle>;
generic::Gradient<LineDirection, Length, LengthPercentage, GradientPosition, Color, Angle>;
impl SpecifiedValueInfo for Gradient {
const SUPPORTED_TYPES: u8 = CssType::GRADIENT;
@ -88,12 +88,12 @@ impl SpecifiedValueInfo for Gradient {
/// A specified gradient kind.
#[cfg(not(feature = "gecko"))]
pub type GradientKind =
generic::GradientKind<LineDirection, Length, LengthOrPercentage, Position, Angle>;
generic::GradientKind<LineDirection, Length, LengthPercentage, Position, Angle>;
/// A specified gradient kind.
#[cfg(feature = "gecko")]
pub type GradientKind =
generic::GradientKind<LineDirection, Length, LengthOrPercentage, GradientPosition, Angle>;
generic::GradientKind<LineDirection, Length, LengthPercentage, GradientPosition, Angle>;
/// A specified gradient line direction.
#[derive(Clone, Debug, MallocSizeOf, PartialEq)]
@ -125,13 +125,13 @@ pub enum GradientPosition {
}
/// A specified ending shape.
pub type EndingShape = generic::EndingShape<Length, LengthOrPercentage>;
pub type EndingShape = generic::EndingShape<Length, LengthPercentage>;
/// A specified gradient item.
pub type GradientItem = generic::GradientItem<Color, LengthOrPercentage>;
pub type GradientItem = generic::GradientItem<Color, LengthPercentage>;
/// A computed color stop.
pub type ColorStop = generic::ColorStop<Color, LengthOrPercentage>;
pub type ColorStop = generic::ColorStop<Color, LengthPercentage>;
/// Specified values for `moz-image-rect`
/// -moz-image-rect(<uri>, top, right, bottom, left);
@ -538,8 +538,8 @@ impl Gradient {
&generic::GradientItem::ColorStop(ref b),
) => match (&a.position, &b.position) {
(
&Some(LengthOrPercentage::Percentage(a)),
&Some(LengthOrPercentage::Percentage(b)),
&Some(LengthPercentage::Percentage(a)),
&Some(LengthPercentage::Percentage(b)),
) => {
return a.0.partial_cmp(&b.0).unwrap_or(Ordering::Equal);
},
@ -698,14 +698,14 @@ impl generic::LineDirection for LineDirection {
// These percentage values can also be keywords.
let x = match *x {
OriginComponent::Center => true,
OriginComponent::Length(LengthOrPercentage::Percentage(
OriginComponent::Length(LengthPercentage::Percentage(
ComputedPercentage(val),
)) => val == 0.5,
_ => false,
};
let y = match *y {
OriginComponent::Side(Y::Top) => true,
OriginComponent::Length(LengthOrPercentage::Percentage(
OriginComponent::Length(LengthPercentage::Percentage(
ComputedPercentage(val),
)) => val == 0.0,
_ => false,
@ -876,8 +876,8 @@ impl EndingShape {
}
if compat_mode == CompatMode::Modern {
let pair: Result<_, ParseError> = input.try(|i| {
let x = LengthOrPercentage::parse(context, i)?;
let y = LengthOrPercentage::parse(context, i)?;
let x = LengthPercentage::parse(context, i)?;
let y = LengthPercentage::parse(context, i)?;
Ok((x, y))
});
if let Ok((x, y)) = pair {
@ -888,11 +888,11 @@ impl EndingShape {
ShapeExtent::FarthestCorner,
)));
}
// -moz- prefixed radial gradient doesn't allow EndingShape's Length or LengthOrPercentage
// -moz- prefixed radial gradient doesn't allow EndingShape's Length or LengthPercentage
// to come before shape keyword. Otherwise it conflicts with <position>.
if compat_mode != CompatMode::Moz {
if let Ok(length) = input.try(|i| Length::parse(context, i)) {
if let Ok(y) = input.try(|i| LengthOrPercentage::parse(context, i)) {
if let Ok(y) = input.try(|i| LengthPercentage::parse(context, i)) {
if compat_mode == CompatMode::Modern {
let _ = input.try(|i| i.expect_ident_matching("ellipse"));
}
@ -904,7 +904,7 @@ impl EndingShape {
if compat_mode == CompatMode::Modern {
let y = input.try(|i| {
i.expect_ident_matching("ellipse")?;
LengthOrPercentage::parse(context, i)
LengthPercentage::parse(context, i)
});
if let Ok(y) = y {
return Ok(generic::EndingShape::Ellipse(Ellipse::Radii(
@ -920,7 +920,7 @@ impl EndingShape {
}
input.try(|i| {
let x = Percentage::parse(context, i)?;
let y = if let Ok(y) = i.try(|i| LengthOrPercentage::parse(context, i)) {
let y = if let Ok(y) = i.try(|i| LengthPercentage::parse(context, i)) {
if compat_mode == CompatMode::Modern {
let _ = i.try(|i| i.expect_ident_matching("ellipse"));
}
@ -929,7 +929,7 @@ impl EndingShape {
if compat_mode == CompatMode::Modern {
i.expect_ident_matching("ellipse")?;
}
LengthOrPercentage::parse(context, i)?
LengthPercentage::parse(context, i)?
};
Ok(generic::EndingShape::Ellipse(Ellipse::Radii(x.into(), y)))
})
@ -963,7 +963,7 @@ impl GradientItem {
loop {
input.parse_until_before(Delimiter::Comma, |input| {
if seen_stop {
if let Ok(hint) = input.try(|i| LengthOrPercentage::parse(context, i)) {
if let Ok(hint) = input.try(|i| LengthPercentage::parse(context, i)) {
seen_stop = false;
items.push(generic::GradientItem::InterpolationHint(hint));
return Ok(());
@ -972,7 +972,7 @@ impl GradientItem {
let stop = ColorStop::parse(context, input)?;
if let Ok(multi_position) = input.try(|i| LengthOrPercentage::parse(context, i)) {
if let Ok(multi_position) = input.try(|i| LengthPercentage::parse(context, i)) {
let stop_color = stop.color.clone();
items.push(generic::GradientItem::ColorStop(stop));
items.push(generic::GradientItem::ColorStop(ColorStop {
@ -1008,7 +1008,7 @@ impl Parse for ColorStop {
) -> Result<Self, ParseError<'i>> {
Ok(ColorStop {
color: Color::parse(context, input)?,
position: input.try(|i| LengthOrPercentage::parse(context, i)).ok(),
position: input.try(|i| LengthPercentage::parse(context, i)).ok(),
})
}
}

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

@ -26,7 +26,7 @@ use style_traits::{ParseError, SpecifiedValueInfo, StyleParseErrorKind};
pub use super::image::{ColorStop, EndingShape as GradientEndingShape, Gradient};
pub use super::image::{GradientKind, Image};
pub use crate::values::specified::calc::CalcLengthOrPercentage;
pub use crate::values::specified::calc::CalcLengthPercentage;
/// Number of app units per pixel
pub const AU_PER_PX: CSSFloat = 60.;
@ -530,7 +530,7 @@ pub enum Length {
/// A calc expression.
///
/// <https://drafts.csswg.org/css-values/#calc-notation>
Calc(Box<CalcLengthOrPercentage>),
Calc(Box<CalcLengthPercentage>),
}
impl From<NoCalcLength> for Length {
@ -736,63 +736,66 @@ impl NonNegativeLength {
/// Either a NonNegativeLength or the `auto` keyword.
pub type NonNegativeLengthOrAuto = Either<NonNegativeLength, Auto>;
/// A length or a percentage value.
/// A `<length-percentage>` value. This can be either a `<length>`, a
/// `<percentage>`, or a combination of both via `calc()`.
///
/// https://drafts.csswg.org/css-values-4/#typedef-length-percentage
#[allow(missing_docs)]
#[derive(Clone, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToCss)]
pub enum LengthOrPercentage {
pub enum LengthPercentage {
Length(NoCalcLength),
Percentage(computed::Percentage),
Calc(Box<CalcLengthOrPercentage>),
Calc(Box<CalcLengthPercentage>),
}
impl From<Length> for LengthOrPercentage {
fn from(len: Length) -> LengthOrPercentage {
impl From<Length> for LengthPercentage {
fn from(len: Length) -> LengthPercentage {
match len {
Length::NoCalc(l) => LengthOrPercentage::Length(l),
Length::Calc(l) => LengthOrPercentage::Calc(l),
Length::NoCalc(l) => LengthPercentage::Length(l),
Length::Calc(l) => LengthPercentage::Calc(l),
}
}
}
impl From<NoCalcLength> for LengthOrPercentage {
impl From<NoCalcLength> for LengthPercentage {
#[inline]
fn from(len: NoCalcLength) -> Self {
LengthOrPercentage::Length(len)
LengthPercentage::Length(len)
}
}
impl From<Percentage> for LengthOrPercentage {
impl From<Percentage> for LengthPercentage {
#[inline]
fn from(pc: Percentage) -> Self {
if pc.is_calc() {
LengthOrPercentage::Calc(Box::new(CalcLengthOrPercentage {
LengthPercentage::Calc(Box::new(CalcLengthPercentage {
percentage: Some(computed::Percentage(pc.get())),
..Default::default()
}))
} else {
LengthOrPercentage::Percentage(computed::Percentage(pc.get()))
LengthPercentage::Percentage(computed::Percentage(pc.get()))
}
}
}
impl From<computed::Percentage> for LengthOrPercentage {
impl From<computed::Percentage> for LengthPercentage {
#[inline]
fn from(pc: computed::Percentage) -> Self {
LengthOrPercentage::Percentage(pc)
LengthPercentage::Percentage(pc)
}
}
impl LengthOrPercentage {
impl LengthPercentage {
#[inline]
/// Returns a `zero` length.
pub fn zero() -> LengthOrPercentage {
LengthOrPercentage::Length(NoCalcLength::zero())
pub fn zero() -> LengthPercentage {
LengthPercentage::Length(NoCalcLength::zero())
}
#[inline]
/// Returns a `0%` value.
pub fn zero_percent() -> LengthOrPercentage {
LengthOrPercentage::Percentage(computed::Percentage::zero())
pub fn zero_percent() -> LengthPercentage {
LengthPercentage::Percentage(computed::Percentage::zero())
}
fn parse_internal<'i, 't>(
@ -810,13 +813,13 @@ impl LengthOrPercentage {
value, ref unit, ..
} if num_context.is_ok(context.parsing_mode, value) => {
return NoCalcLength::parse_dimension(context, value, unit)
.map(LengthOrPercentage::Length)
.map(LengthPercentage::Length)
.map_err(|()| location.new_unexpected_token_error(token.clone()));
},
Token::Percentage { unit_value, .. }
if num_context.is_ok(context.parsing_mode, unit_value) =>
{
return Ok(LengthOrPercentage::Percentage(computed::Percentage(
return Ok(LengthPercentage::Percentage(computed::Percentage(
unit_value,
)));
}
@ -827,7 +830,7 @@ impl LengthOrPercentage {
{
return Err(location.new_unexpected_token_error(token.clone()));
} else {
return Ok(LengthOrPercentage::Length(NoCalcLength::from_px(value)));
return Ok(LengthPercentage::Length(NoCalcLength::from_px(value)));
}
},
Token::Function(ref name) if name.eq_ignore_ascii_case("calc") => {},
@ -838,7 +841,7 @@ impl LengthOrPercentage {
let calc = input.parse_nested_block(|i| {
CalcNode::parse_length_or_percentage(context, i, num_context)
})?;
Ok(LengthOrPercentage::Calc(Box::new(calc)))
Ok(LengthPercentage::Calc(Box::new(calc)))
}
/// Parse a non-negative length.
@ -846,7 +849,7 @@ impl LengthOrPercentage {
pub fn parse_non_negative<'i, 't>(
context: &ParserContext,
input: &mut Parser<'i, 't>,
) -> Result<LengthOrPercentage, ParseError<'i>> {
) -> Result<LengthPercentage, ParseError<'i>> {
Self::parse_non_negative_quirky(context, input, AllowQuirks::No)
}
@ -856,7 +859,7 @@ impl LengthOrPercentage {
context: &ParserContext,
input: &mut Parser<'i, 't>,
allow_quirks: AllowQuirks,
) -> Result<LengthOrPercentage, ParseError<'i>> {
) -> Result<LengthPercentage, ParseError<'i>> {
Self::parse_internal(
context,
input,
@ -866,7 +869,7 @@ impl LengthOrPercentage {
}
}
impl Parse for LengthOrPercentage {
impl Parse for LengthPercentage {
#[inline]
fn parse<'i, 't>(
context: &ParserContext,
@ -876,7 +879,7 @@ impl Parse for LengthOrPercentage {
}
}
impl LengthOrPercentage {
impl LengthPercentage {
/// Parses a length or a percentage, allowing the unitless length quirk.
/// <https://quirks.spec.whatwg.org/#the-unitless-length-quirk>
#[inline]
@ -889,13 +892,13 @@ impl LengthOrPercentage {
}
}
impl IsZeroLength for LengthOrPercentage {
impl IsZeroLength for LengthPercentage {
#[inline]
fn is_zero_length(&self) -> bool {
match *self {
LengthOrPercentage::Length(l) => l.is_zero_length(),
LengthOrPercentage::Percentage(p) => p.0 == 0.0,
LengthOrPercentage::Calc(_) => false,
LengthPercentage::Length(l) => l.is_zero_length(),
LengthPercentage::Percentage(p) => p.0 == 0.0,
LengthPercentage::Calc(_) => false,
}
}
}
@ -903,12 +906,12 @@ impl IsZeroLength for LengthOrPercentage {
/// Either a `<length>`, a `<percentage>`, or the `auto` keyword.
#[allow(missing_docs)]
#[derive(Clone, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToCss)]
pub enum LengthOrPercentageOrAuto {
LengthOrPercentage(LengthOrPercentage),
pub enum LengthPercentageOrAuto {
LengthPercentage(LengthPercentage),
Auto,
}
impl LengthOrPercentageOrAuto {
impl LengthPercentageOrAuto {
fn parse_internal<'i, 't>(
context: &ParserContext,
input: &mut Parser<'i, 't>,
@ -916,10 +919,10 @@ impl LengthOrPercentageOrAuto {
allow_quirks: AllowQuirks,
) -> Result<Self, ParseError<'i>> {
if input.try(|i| i.expect_ident_matching("auto")).is_ok() {
return Ok(LengthOrPercentageOrAuto::Auto);
return Ok(LengthPercentageOrAuto::Auto);
}
Ok(LengthOrPercentageOrAuto::LengthOrPercentage(LengthOrPercentage::parse_internal(
Ok(LengthPercentageOrAuto::LengthPercentage(LengthPercentage::parse_internal(
context,
input,
num_context,
@ -932,7 +935,7 @@ impl LengthOrPercentageOrAuto {
pub fn parse_non_negative<'i, 't>(
context: &ParserContext,
input: &mut Parser<'i, 't>,
) -> Result<LengthOrPercentageOrAuto, ParseError<'i>> {
) -> Result<LengthPercentageOrAuto, ParseError<'i>> {
Self::parse_non_negative_quirky(context, input, AllowQuirks::No)
}
@ -953,18 +956,18 @@ impl LengthOrPercentageOrAuto {
/// Returns the `auto` value.
pub fn auto() -> Self {
LengthOrPercentageOrAuto::Auto
LengthPercentageOrAuto::Auto
}
/// Returns a value representing a `0` length.
pub fn zero() -> Self {
LengthOrPercentageOrAuto::LengthOrPercentage(LengthOrPercentage::zero())
LengthPercentageOrAuto::LengthPercentage(LengthPercentage::zero())
}
/// Returns a value representing `0%`.
#[inline]
pub fn zero_percent() -> Self {
LengthOrPercentageOrAuto::LengthOrPercentage(LengthOrPercentage::zero_percent())
LengthPercentageOrAuto::LengthPercentage(LengthPercentage::zero_percent())
}
/// Parses, with quirks.
@ -978,7 +981,7 @@ impl LengthOrPercentageOrAuto {
}
}
impl Parse for LengthOrPercentageOrAuto {
impl Parse for LengthPercentageOrAuto {
#[inline]
fn parse<'i, 't>(
context: &ParserContext,
@ -988,43 +991,43 @@ impl Parse for LengthOrPercentageOrAuto {
}
}
/// A wrapper of LengthOrPercentageOrAuto, whose value must be >= 0.
pub type NonNegativeLengthOrPercentageOrAuto = NonNegative<LengthOrPercentageOrAuto>;
/// A wrapper of LengthPercentageOrAuto, whose value must be >= 0.
pub type NonNegativeLengthPercentageOrAuto = NonNegative<LengthPercentageOrAuto>;
impl IsAuto for NonNegativeLengthOrPercentageOrAuto {
impl IsAuto for NonNegativeLengthPercentageOrAuto {
#[inline]
fn is_auto(&self) -> bool {
*self == Self::auto()
}
}
impl NonNegativeLengthOrPercentageOrAuto {
impl NonNegativeLengthPercentageOrAuto {
/// 0
#[inline]
pub fn zero() -> Self {
NonNegative(LengthOrPercentageOrAuto::zero())
NonNegative(LengthPercentageOrAuto::zero())
}
/// 0%
#[inline]
pub fn zero_percent() -> Self {
NonNegative(LengthOrPercentageOrAuto::zero_percent())
NonNegative(LengthPercentageOrAuto::zero_percent())
}
/// `auto`
#[inline]
pub fn auto() -> Self {
NonNegative(LengthOrPercentageOrAuto::Auto)
NonNegative(LengthPercentageOrAuto::Auto)
}
}
impl Parse for NonNegativeLengthOrPercentageOrAuto {
impl Parse for NonNegativeLengthPercentageOrAuto {
#[inline]
fn parse<'i, 't>(
context: &ParserContext,
input: &mut Parser<'i, 't>,
) -> Result<Self, ParseError<'i>> {
Ok(NonNegative(LengthOrPercentageOrAuto::parse_non_negative(
Ok(NonNegative(LengthPercentageOrAuto::parse_non_negative(
context, input,
)?))
}
@ -1033,12 +1036,12 @@ impl Parse for NonNegativeLengthOrPercentageOrAuto {
/// Either a `<length>`, a `<percentage>`, or the `none` keyword.
#[derive(Clone, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToCss)]
#[allow(missing_docs)]
pub enum LengthOrPercentageOrNone {
LengthOrPercentage(LengthOrPercentage),
pub enum LengthPercentageOrNone {
LengthPercentage(LengthPercentage),
None,
}
impl LengthOrPercentageOrNone {
impl LengthPercentageOrNone {
fn parse_internal<'i, 't>(
context: &ParserContext,
input: &mut Parser<'i, 't>,
@ -1046,10 +1049,10 @@ impl LengthOrPercentageOrNone {
allow_quirks: AllowQuirks,
) -> Result<Self, ParseError<'i>> {
if input.try(|i| i.expect_ident_matching("none")).is_ok() {
return Ok(LengthOrPercentageOrNone::None);
return Ok(LengthPercentageOrNone::None);
}
Ok(LengthOrPercentageOrNone::LengthOrPercentage(LengthOrPercentage::parse_internal(
Ok(LengthPercentageOrNone::LengthPercentage(LengthPercentage::parse_internal(
context,
input,
num_context,
@ -1057,7 +1060,7 @@ impl LengthOrPercentageOrNone {
)?))
}
/// Parse a non-negative LengthOrPercentageOrNone.
/// Parse a non-negative LengthPercentageOrNone.
#[inline]
pub fn parse_non_negative<'i, 't>(
context: &ParserContext,
@ -1066,7 +1069,7 @@ impl LengthOrPercentageOrNone {
Self::parse_non_negative_quirky(context, input, AllowQuirks::No)
}
/// Parse a non-negative LengthOrPercentageOrNone, with quirks.
/// Parse a non-negative LengthPercentageOrNone, with quirks.
#[inline]
pub fn parse_non_negative_quirky<'i, 't>(
context: &ParserContext,
@ -1082,7 +1085,7 @@ impl LengthOrPercentageOrNone {
}
}
impl Parse for LengthOrPercentageOrNone {
impl Parse for LengthPercentageOrNone {
#[inline]
fn parse<'i, 't>(
context: &ParserContext,
@ -1092,38 +1095,38 @@ impl Parse for LengthOrPercentageOrNone {
}
}
/// A wrapper of LengthOrPercentage, whose value must be >= 0.
pub type NonNegativeLengthOrPercentage = NonNegative<LengthOrPercentage>;
/// A wrapper of LengthPercentage, whose value must be >= 0.
pub type NonNegativeLengthPercentage = NonNegative<LengthPercentage>;
/// Either a computed NonNegativeLength or the `normal` keyword.
pub type NonNegativeLengthOrNormal = Either<NonNegativeLength, Normal>;
/// Either a NonNegativeLengthOrPercentage or the `normal` keyword.
pub type NonNegativeLengthOrPercentageOrNormal = Either<NonNegativeLengthOrPercentage, Normal>;
/// Either a NonNegativeLengthPercentage or the `normal` keyword.
pub type NonNegativeLengthPercentageOrNormal = Either<NonNegativeLengthPercentage, Normal>;
impl From<NoCalcLength> for NonNegativeLengthOrPercentage {
impl From<NoCalcLength> for NonNegativeLengthPercentage {
#[inline]
fn from(len: NoCalcLength) -> Self {
NonNegative::<LengthOrPercentage>(LengthOrPercentage::from(len))
NonNegative::<LengthPercentage>(LengthPercentage::from(len))
}
}
impl Parse for NonNegativeLengthOrPercentage {
impl Parse for NonNegativeLengthPercentage {
#[inline]
fn parse<'i, 't>(
context: &ParserContext,
input: &mut Parser<'i, 't>,
) -> Result<Self, ParseError<'i>> {
LengthOrPercentage::parse_non_negative(context, input)
.map(NonNegative::<LengthOrPercentage>)
LengthPercentage::parse_non_negative(context, input)
.map(NonNegative::<LengthPercentage>)
}
}
impl NonNegativeLengthOrPercentage {
impl NonNegativeLengthPercentage {
#[inline]
/// Returns a `zero` length.
pub fn zero() -> Self {
NonNegative::<LengthOrPercentage>(LengthOrPercentage::zero())
NonNegative::<LengthPercentage>(LengthPercentage::zero())
}
/// Parses a length or a percentage, allowing the unitless length quirk.
@ -1134,8 +1137,8 @@ impl NonNegativeLengthOrPercentage {
input: &mut Parser<'i, 't>,
allow_quirks: AllowQuirks,
) -> Result<Self, ParseError<'i>> {
LengthOrPercentage::parse_non_negative_quirky(context, input, allow_quirks)
.map(NonNegative::<LengthOrPercentage>)
LengthPercentage::parse_non_negative_quirky(context, input, allow_quirks)
.map(NonNegative::<LengthPercentage>)
}
}
@ -1172,7 +1175,7 @@ impl LengthOrNumber {
}
/// A specified value for `min-width`, `min-height`, `width` or `height` property.
pub type MozLength = GenericMozLength<LengthOrPercentageOrAuto>;
pub type MozLength = GenericMozLength<LengthPercentageOrAuto>;
impl Parse for MozLength {
fn parse<'i, 't>(
@ -1195,25 +1198,25 @@ impl MozLength {
}
let length =
LengthOrPercentageOrAuto::parse_non_negative_quirky(context, input, allow_quirks)?;
Ok(GenericMozLength::LengthOrPercentageOrAuto(length))
LengthPercentageOrAuto::parse_non_negative_quirky(context, input, allow_quirks)?;
Ok(GenericMozLength::LengthPercentageOrAuto(length))
}
/// Returns `auto`.
#[inline]
pub fn auto() -> Self {
GenericMozLength::LengthOrPercentageOrAuto(LengthOrPercentageOrAuto::auto())
GenericMozLength::LengthPercentageOrAuto(LengthPercentageOrAuto::auto())
}
/// Returns `0%`.
#[inline]
pub fn zero_percent() -> Self {
GenericMozLength::LengthOrPercentageOrAuto(LengthOrPercentageOrAuto::zero_percent())
GenericMozLength::LengthPercentageOrAuto(LengthPercentageOrAuto::zero_percent())
}
}
/// A specified value for `max-width` or `max-height` property.
pub type MaxLength = GenericMaxLength<LengthOrPercentageOrNone>;
pub type MaxLength = GenericMaxLength<LengthPercentageOrNone>;
impl Parse for MaxLength {
fn parse<'i, 't>(
@ -1236,7 +1239,7 @@ impl MaxLength {
}
let length =
LengthOrPercentageOrNone::parse_non_negative_quirky(context, input, allow_quirks)?;
Ok(GenericMaxLength::LengthOrPercentageOrNone(length))
LengthPercentageOrNone::parse_non_negative_quirky(context, input, allow_quirks)?;
Ok(GenericMaxLength::LengthPercentageOrNone(length))
}
}

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

@ -55,12 +55,12 @@ pub use self::font::{MozScriptLevel, MozScriptMinSize, MozScriptSizeMultiplier,
pub use self::gecko::ScrollSnapPoint;
pub use self::image::{ColorStop, EndingShape as GradientEndingShape, Gradient};
pub use self::image::{GradientItem, GradientKind, Image, ImageLayer, MozImageRect};
pub use self::length::{AbsoluteLength, CalcLengthOrPercentage, CharacterWidth};
pub use self::length::{AbsoluteLength, CalcLengthPercentage, CharacterWidth};
pub use self::length::{FontRelativeLength, Length, LengthOrNumber};
pub use self::length::{LengthOrPercentage, LengthOrPercentageOrAuto};
pub use self::length::{LengthOrPercentageOrNone, MaxLength, MozLength};
pub use self::length::{LengthPercentage, LengthPercentageOrAuto};
pub use self::length::{LengthPercentageOrNone, MaxLength, MozLength};
pub use self::length::{NoCalcLength, ViewportPercentageLength};
pub use self::length::{NonNegativeLengthOrPercentage, NonNegativeLengthOrPercentageOrAuto};
pub use self::length::{NonNegativeLengthPercentage, NonNegativeLengthPercentageOrAuto};
#[cfg(feature = "gecko")]
pub use self::list::ListStyleType;
pub use self::list::{QuotePair, Quotes};
@ -567,20 +567,20 @@ impl Parse for PositiveInteger {
}
/// The specified value of a grid `<track-breadth>`
pub type TrackBreadth = GenericTrackBreadth<LengthOrPercentage>;
pub type TrackBreadth = GenericTrackBreadth<LengthPercentage>;
/// The specified value of a grid `<track-size>`
pub type TrackSize = GenericTrackSize<LengthOrPercentage>;
pub type TrackSize = GenericTrackSize<LengthPercentage>;
/// The specified value of a grid `<track-list>`
/// (could also be `<auto-track-list>` or `<explicit-track-list>`)
pub type TrackList = GenericTrackList<LengthOrPercentage, Integer>;
pub type TrackList = GenericTrackList<LengthPercentage, Integer>;
/// The specified value of a `<grid-line>`.
pub type GridLine = GenericGridLine<Integer>;
/// `<grid-template-rows> | <grid-template-columns>`
pub type GridTemplateComponent = GenericGridTemplateComponent<LengthOrPercentage, Integer>;
pub type GridTemplateComponent = GenericGridTemplateComponent<LengthPercentage, Integer>;
#[derive(Clone, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo)]
/// rect(<top>, <left>, <bottom>, <right>) used by clip and image-region

34
components/style/values/specified/position.rs
View file

@ -10,12 +10,12 @@
use crate::hash::FxHashMap;
use crate::parser::{Parse, ParserContext};
use crate::str::HTML_SPACE_CHARACTERS;
use crate::values::computed::LengthOrPercentage as ComputedLengthOrPercentage;
use crate::values::computed::LengthPercentage as ComputedLengthPercentage;
use crate::values::computed::{Context, Percentage, ToComputedValue};
use crate::values::generics::position::Position as GenericPosition;
use crate::values::generics::position::ZIndex as GenericZIndex;
use crate::values::specified::transform::OriginComponent;
use crate::values::specified::{AllowQuirks, Integer, LengthOrPercentage};
use crate::values::specified::{AllowQuirks, Integer, LengthPercentage};
use crate::values::{Either, None_};
use cssparser::Parser;
use selectors::parser::SelectorParseErrorKind;
@ -39,9 +39,9 @@ pub enum PositionComponent<S> {
/// `center`
Center,
/// `<lop>`
Length(LengthOrPercentage),
Length(LengthPercentage),
/// `<side> <lop>?`
Side(S, Option<LengthOrPercentage>),
Side(S, Option<LengthPercentage>),
}
/// A keyword for the X direction.
@ -121,7 +121,7 @@ impl Position {
}
if let Ok(y_keyword) = input.try(Y::parse) {
let y_lop = input
.try(|i| LengthOrPercentage::parse_quirky(context, i, allow_quirks))
.try(|i| LengthPercentage::parse_quirky(context, i, allow_quirks))
.ok();
let x_pos = PositionComponent::Side(x_keyword, lop);
let y_pos = PositionComponent::Side(y_keyword, y_lop);
@ -137,7 +137,7 @@ impl Position {
return Ok(Self::new(x_pos, y_pos));
}
if let Ok(y_lop) =
input.try(|i| LengthOrPercentage::parse_quirky(context, i, allow_quirks))
input.try(|i| LengthPercentage::parse_quirky(context, i, allow_quirks))
{
let y_pos = PositionComponent::Length(y_lop);
return Ok(Self::new(x_pos, y_pos));
@ -151,11 +151,11 @@ impl Position {
let y_keyword = Y::parse(input)?;
let lop_and_x_pos: Result<_, ParseError> = input.try(|i| {
let y_lop = i
.try(|i| LengthOrPercentage::parse_quirky(context, i, allow_quirks))
.try(|i| LengthPercentage::parse_quirky(context, i, allow_quirks))
.ok();
if let Ok(x_keyword) = i.try(X::parse) {
let x_lop = i
.try(|i| LengthOrPercentage::parse_quirky(context, i, allow_quirks))
.try(|i| LengthPercentage::parse_quirky(context, i, allow_quirks))
.ok();
let x_pos = PositionComponent::Side(x_keyword, x_lop);
return Ok((y_lop, x_pos));
@ -231,12 +231,12 @@ impl<S: Parse> PositionComponent<S> {
if input.try(|i| i.expect_ident_matching("center")).is_ok() {
return Ok(PositionComponent::Center);
}
if let Ok(lop) = input.try(|i| LengthOrPercentage::parse_quirky(context, i, allow_quirks)) {
if let Ok(lop) = input.try(|i| LengthPercentage::parse_quirky(context, i, allow_quirks)) {
return Ok(PositionComponent::Length(lop));
}
let keyword = S::parse(context, input)?;
let lop = input
.try(|i| LengthOrPercentage::parse_quirky(context, i, allow_quirks))
.try(|i| LengthPercentage::parse_quirky(context, i, allow_quirks))
.ok();
Ok(PositionComponent::Side(keyword, lop))
}
@ -245,25 +245,25 @@ impl<S: Parse> PositionComponent<S> {
impl<S> PositionComponent<S> {
/// `0%`
pub fn zero() -> Self {
PositionComponent::Length(LengthOrPercentage::Percentage(Percentage::zero()))
PositionComponent::Length(LengthPercentage::Percentage(Percentage::zero()))
}
}
impl<S: Side> ToComputedValue for PositionComponent<S> {
type ComputedValue = ComputedLengthOrPercentage;
type ComputedValue = ComputedLengthPercentage;
fn to_computed_value(&self, context: &Context) -> Self::ComputedValue {
match *self {
PositionComponent::Center => ComputedLengthOrPercentage::new_percent(Percentage(0.5)),
PositionComponent::Center => ComputedLengthPercentage::new_percent(Percentage(0.5)),
PositionComponent::Side(ref keyword, None) => {
let p = Percentage(if keyword.is_start() { 0. } else { 1. });
ComputedLengthOrPercentage::new_percent(p)
ComputedLengthPercentage::new_percent(p)
},
PositionComponent::Side(ref keyword, Some(ref length)) if !keyword.is_start() => {
let length = length.to_computed_value(context);
let p = Percentage(1. - length.percentage());
let l = -length.unclamped_length();
ComputedLengthOrPercentage::with_clamping_mode(
ComputedLengthPercentage::with_clamping_mode(
l,
Some(p),
length.clamping_mode,
@ -372,7 +372,7 @@ impl LegacyPosition {
}
let x_pos = OriginComponent::Side(x_keyword);
if let Ok(y_lop) =
input.try(|i| LengthOrPercentage::parse_quirky(context, i, allow_quirks))
input.try(|i| LengthPercentage::parse_quirky(context, i, allow_quirks))
{
return Ok(Self::new(x_pos, OriginComponent::Length(y_lop)));
}
@ -385,7 +385,7 @@ impl LegacyPosition {
return Ok(Self::new(x_pos, y_pos));
}
if let Ok(y_lop) =
input.try(|i| LengthOrPercentage::parse_quirky(context, i, allow_quirks))
input.try(|i| LengthPercentage::parse_quirky(context, i, allow_quirks))
{
let y_pos = OriginComponent::Length(y_lop);
return Ok(Self::new(x_pos, y_pos));

32
components/style/values/specified/svg.rs
View file

@ -8,8 +8,8 @@ use crate::parser::{Parse, ParserContext};
use crate::values::generics::svg as generic;
use crate::values::specified::color::Color;
use crate::values::specified::url::SpecifiedUrl;
use crate::values::specified::LengthOrPercentage;
use crate::values::specified::{NonNegativeLengthOrPercentage, NonNegativeNumber};
use crate::values::specified::LengthPercentage;
use crate::values::specified::{NonNegativeLengthPercentage, NonNegativeNumber};
use crate::values::specified::{Number, Opacity};
use crate::values::CustomIdent;
use cssparser::Parser;
@ -50,11 +50,11 @@ fn parse_context_value<'i, 't, T>(
/// A value of <length> | <percentage> | <number> for stroke-dashoffset.
/// <https://www.w3.org/TR/SVG11/painting.html#StrokeProperties>
pub type SvgLengthOrPercentageOrNumber =
generic::SvgLengthOrPercentageOrNumber<LengthOrPercentage, Number>;
pub type SvgLengthPercentageOrNumber =
generic::SvgLengthPercentageOrNumber<LengthPercentage, Number>;
/// <length> | <percentage> | <number> | context-value
pub type SVGLength = generic::SVGLength<SvgLengthOrPercentageOrNumber>;
pub type SVGLength = generic::SVGLength<SvgLengthPercentageOrNumber>;
impl Parse for SVGLength {
fn parse<'i, 't>(
@ -62,25 +62,25 @@ impl Parse for SVGLength {
input: &mut Parser<'i, 't>,
) -> Result<Self, ParseError<'i>> {
input
.try(|i| SvgLengthOrPercentageOrNumber::parse(context, i))
.try(|i| SvgLengthPercentageOrNumber::parse(context, i))
.map(Into::into)
.or_else(|_| parse_context_value(input, generic::SVGLength::ContextValue))
}
}
impl From<SvgLengthOrPercentageOrNumber> for SVGLength {
fn from(length: SvgLengthOrPercentageOrNumber) -> Self {
impl From<SvgLengthPercentageOrNumber> for SVGLength {
fn from(length: SvgLengthPercentageOrNumber) -> Self {
generic::SVGLength::Length(length)
}
}
/// A value of <length> | <percentage> | <number> for stroke-width/stroke-dasharray.
/// <https://www.w3.org/TR/SVG11/painting.html#StrokeProperties>
pub type NonNegativeSvgLengthOrPercentageOrNumber =
generic::SvgLengthOrPercentageOrNumber<NonNegativeLengthOrPercentage, NonNegativeNumber>;
pub type NonNegativeSvgLengthPercentageOrNumber =
generic::SvgLengthPercentageOrNumber<NonNegativeLengthPercentage, NonNegativeNumber>;
/// A non-negative version of SVGLength.
pub type SVGWidth = generic::SVGLength<NonNegativeSvgLengthOrPercentageOrNumber>;
pub type SVGWidth = generic::SVGLength<NonNegativeSvgLengthPercentageOrNumber>;
impl Parse for SVGWidth {
fn parse<'i, 't>(
@ -88,20 +88,20 @@ impl Parse for SVGWidth {
input: &mut Parser<'i, 't>,
) -> Result<Self, ParseError<'i>> {
input
.try(|i| NonNegativeSvgLengthOrPercentageOrNumber::parse(context, i))
.try(|i| NonNegativeSvgLengthPercentageOrNumber::parse(context, i))
.map(Into::into)
.or_else(|_| parse_context_value(input, generic::SVGLength::ContextValue))
}
}
impl From<NonNegativeSvgLengthOrPercentageOrNumber> for SVGWidth {
fn from(length: NonNegativeSvgLengthOrPercentageOrNumber) -> Self {
impl From<NonNegativeSvgLengthPercentageOrNumber> for SVGWidth {
fn from(length: NonNegativeSvgLengthPercentageOrNumber) -> Self {
generic::SVGLength::Length(length)
}
}
/// [ <length> | <percentage> | <number> ]# | context-value
pub type SVGStrokeDashArray = generic::SVGStrokeDashArray<NonNegativeSvgLengthOrPercentageOrNumber>;
pub type SVGStrokeDashArray = generic::SVGStrokeDashArray<NonNegativeSvgLengthPercentageOrNumber>;
impl Parse for SVGStrokeDashArray {
fn parse<'i, 't>(
@ -110,7 +110,7 @@ impl Parse for SVGStrokeDashArray {
) -> Result<Self, ParseError<'i>> {
if let Ok(values) = input.try(|i| {
CommaWithSpace::parse(i, |i| {
NonNegativeSvgLengthOrPercentageOrNumber::parse(context, i)
NonNegativeSvgLengthPercentageOrNumber::parse(context, i)
})
}) {
Ok(generic::SVGStrokeDashArray::Values(values))

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

@ -16,8 +16,8 @@ use crate::values::generics::text::LineHeight as GenericLineHeight;
use crate::values::generics::text::MozTabSize as GenericMozTabSize;
use crate::values::generics::text::Spacing;
use crate::values::specified::length::{FontRelativeLength, Length};
use crate::values::specified::length::{LengthOrPercentage, NoCalcLength};
use crate::values::specified::length::{NonNegativeLength, NonNegativeLengthOrPercentage};
use crate::values::specified::length::{LengthPercentage, NoCalcLength};
use crate::values::specified::length::{NonNegativeLength, NonNegativeLengthPercentage};
use crate::values::specified::{AllowQuirks, Integer, NonNegativeNumber, Number};
use cssparser::{Parser, Token};
use selectors::parser::SelectorParseErrorKind;
@ -34,10 +34,10 @@ pub type InitialLetter = GenericInitialLetter<Number, Integer>;
pub type LetterSpacing = Spacing<Length>;
/// A specified value for the `word-spacing` property.
pub type WordSpacing = Spacing<LengthOrPercentage>;
pub type WordSpacing = Spacing<LengthPercentage>;
/// A specified value for the `line-height` property.
pub type LineHeight = GenericLineHeight<NonNegativeNumber, NonNegativeLengthOrPercentage>;
pub type LineHeight = GenericLineHeight<NonNegativeNumber, NonNegativeLengthPercentage>;
impl Parse for InitialLetter {
fn parse<'i, 't>(
@ -70,7 +70,7 @@ impl Parse for WordSpacing {
input: &mut Parser<'i, 't>,
) -> Result<Self, ParseError<'i>> {
Spacing::parse_with(context, input, |c, i| {
LengthOrPercentage::parse_quirky(c, i, AllowQuirks::Yes)
LengthPercentage::parse_quirky(c, i, AllowQuirks::Yes)
})
}
}
@ -83,7 +83,7 @@ impl Parse for LineHeight {
if let Ok(number) = input.try(|i| NonNegativeNumber::parse(context, i)) {
return Ok(GenericLineHeight::Number(number));
}
if let Ok(nlop) = input.try(|i| NonNegativeLengthOrPercentage::parse(context, i)) {
if let Ok(nlop) = input.try(|i| NonNegativeLengthPercentage::parse(context, i)) {
return Ok(GenericLineHeight::Length(nlop));
}
let location = input.current_source_location();
@ -118,15 +118,15 @@ impl ToComputedValue for LineHeight {
},
GenericLineHeight::Length(ref non_negative_lop) => {
let result = match non_negative_lop.0 {
LengthOrPercentage::Length(NoCalcLength::Absolute(ref abs)) => {
LengthPercentage::Length(NoCalcLength::Absolute(ref abs)) => {
context
.maybe_zoom_text(abs.to_computed_value(context).into())
.0
},
LengthOrPercentage::Length(ref length) => length.to_computed_value(context),
LengthOrPercentage::Percentage(ref p) => FontRelativeLength::Em(p.0)
LengthPercentage::Length(ref length) => length.to_computed_value(context),
LengthPercentage::Percentage(ref p) => FontRelativeLength::Em(p.0)
.to_computed_value(context, FontBaseSize::CurrentStyle),
LengthOrPercentage::Calc(ref calc) => {
LengthPercentage::Calc(ref calc) => {
let computed_calc =
calc.to_computed_value_zoomed(context, FontBaseSize::CurrentStyle);
let font_relative_length =

38
components/style/values/specified/transform.rs
View file

@ -5,12 +5,12 @@
//! Specified types for CSS values that are related to transformations.
use crate::parser::{Parse, ParserContext};
use crate::values::computed::{Context, LengthOrPercentage as ComputedLengthOrPercentage};
use crate::values::computed::{Context, LengthPercentage as ComputedLengthPercentage};
use crate::values::computed::{Percentage as ComputedPercentage, ToComputedValue};
use crate::values::generics::transform as generic;
use crate::values::generics::transform::{Matrix, Matrix3D};
use crate::values::specified::position::{Side, X, Y};
use crate::values::specified::{self, Angle, Integer, Length, LengthOrPercentage, Number};
use crate::values::specified::{self, Angle, Integer, Length, LengthPercentage, Number};
use cssparser::Parser;
use style_traits::{ParseError, StyleParseErrorKind};
@ -18,7 +18,7 @@ pub use crate::values::generics::transform::TransformStyle;
/// A single operation in a specified CSS `transform`
pub type TransformOperation =
generic::TransformOperation<Angle, Number, Length, Integer, LengthOrPercentage>;
generic::TransformOperation<Angle, Number, Length, Integer, LengthPercentage>;
/// A specified CSS `transform`
pub type Transform = generic::Transform<TransformOperation>;
@ -105,20 +105,20 @@ impl Transform {
}))
},
"translate" => {
let sx = specified::LengthOrPercentage::parse(context, input)?;
let sx = specified::LengthPercentage::parse(context, input)?;
if input.try(|input| input.expect_comma()).is_ok() {
let sy = specified::LengthOrPercentage::parse(context, input)?;
let sy = specified::LengthPercentage::parse(context, input)?;
Ok(generic::TransformOperation::Translate(sx, Some(sy)))
} else {
Ok(generic::TransformOperation::Translate(sx, None))
}
},
"translatex" => {
let tx = specified::LengthOrPercentage::parse(context, input)?;
let tx = specified::LengthPercentage::parse(context, input)?;
Ok(generic::TransformOperation::TranslateX(tx))
},
"translatey" => {
let ty = specified::LengthOrPercentage::parse(context, input)?;
let ty = specified::LengthPercentage::parse(context, input)?;
Ok(generic::TransformOperation::TranslateY(ty))
},
"translatez" => {
@ -126,9 +126,9 @@ impl Transform {
Ok(generic::TransformOperation::TranslateZ(tz))
},
"translate3d" => {
let tx = specified::LengthOrPercentage::parse(context, input)?;
let tx = specified::LengthPercentage::parse(context, input)?;
input.expect_comma()?;
let ty = specified::LengthOrPercentage::parse(context, input)?;
let ty = specified::LengthPercentage::parse(context, input)?;
input.expect_comma()?;
let tz = specified::Length::parse(context, input)?;
Ok(generic::TransformOperation::Translate3D(tx, ty, tz))
@ -236,7 +236,7 @@ pub enum OriginComponent<S> {
/// `center`
Center,
/// `<lop>`
Length(LengthOrPercentage),
Length(LengthPercentage),
/// `<side>`
Side(S),
}
@ -306,7 +306,7 @@ where
if input.try(|i| i.expect_ident_matching("center")).is_ok() {
return Ok(OriginComponent::Center);
}
if let Ok(lop) = input.try(|i| LengthOrPercentage::parse(context, i)) {
if let Ok(lop) = input.try(|i| LengthPercentage::parse(context, i)) {
return Ok(OriginComponent::Length(lop));
}
let keyword = S::parse(context, input)?;
@ -318,17 +318,17 @@ impl<S> ToComputedValue for OriginComponent<S>
where
S: Side,
{
type ComputedValue = ComputedLengthOrPercentage;
type ComputedValue = ComputedLengthPercentage;
fn to_computed_value(&self, context: &Context) -> Self::ComputedValue {
match *self {
OriginComponent::Center => {
ComputedLengthOrPercentage::new_percent(ComputedPercentage(0.5))
ComputedLengthPercentage::new_percent(ComputedPercentage(0.5))
},
OriginComponent::Length(ref length) => length.to_computed_value(context),
OriginComponent::Side(ref keyword) => {
let p = ComputedPercentage(if keyword.is_start() { 0. } else { 1. });
ComputedLengthOrPercentage::new_percent(p)
ComputedLengthPercentage::new_percent(p)
},
}
}
@ -341,7 +341,7 @@ where
impl<S> OriginComponent<S> {
/// `0%`
pub fn zero() -> Self {
OriginComponent::Length(LengthOrPercentage::Percentage(ComputedPercentage::zero()))
OriginComponent::Length(LengthPercentage::Percentage(ComputedPercentage::zero()))
}
}
@ -393,7 +393,7 @@ impl Parse for Rotate {
}
/// A specified CSS `translate`
pub type Translate = generic::Translate<LengthOrPercentage, Length>;
pub type Translate = generic::Translate<LengthPercentage, Length>;
impl Parse for Translate {
fn parse<'i, 't>(
@ -404,8 +404,8 @@ impl Parse for Translate {
return Ok(generic::Translate::None);
}
let tx = specified::LengthOrPercentage::parse(context, input)?;
if let Ok(ty) = input.try(|i| specified::LengthOrPercentage::parse(context, i)) {
let tx = specified::LengthPercentage::parse(context, input)?;
if let Ok(ty) = input.try(|i| specified::LengthPercentage::parse(context, i)) {
if let Ok(tz) = input.try(|i| specified::Length::parse(context, i)) {
// 'translate: <length-percentage> <length-percentage> <length>'
return Ok(generic::Translate::Translate3D(tx, ty, tz));
@ -418,7 +418,7 @@ impl Parse for Translate {
// 'translate: <length-percentage> '
Ok(generic::Translate::Translate(
tx,
specified::LengthOrPercentage::zero(),
specified::LengthPercentage::zero(),
))
}
}