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

Auto merge of #19766 - jonleighton:issue-19765, r=emilio

Browse source 
Move image-orientation property outside of mako

Fixes https://github.com/servo/servo/issues/19765

r? emilio

<!-- Reviewable:start -->
---
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/19766)
<!-- Reviewable:end -->
This commit is contained in:
bors-servo 2018-01-14 16:55:15 -06:00 • committed by GitHub
commit ec34023d7a
6 changed files with 228 additions and 189 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -4609,7 +4609,8 @@ fn static_assert() {
pub fn clone_image_orientation(&self) -> longhands::image_orientation::computed_value::T {
use gecko_bindings::structs::nsStyleImageOrientation_Angles;
use properties::longhands::image_orientation::computed_value::{Orientation, T};
use properties::longhands::image_orientation::computed_value::T;
use values::computed::Orientation;
let gecko_orientation = self.gecko.mImageOrientation.mOrientation;
if gecko_orientation & structs::nsStyleImageOrientation_Bits_FROM_IMAGE_MASK as u8 != 0 {

196
components/style/properties/longhand/inherited_box.mako.rs
View file

@ -57,191 +57,11 @@ ${helpers.single_keyword("image-rendering",
animation_value_type="discrete",
spec="https://drafts.csswg.org/css-images/#propdef-image-rendering")}
// Image Orientation
<%helpers:longhand name="image-orientation"
products="gecko"
animation_value_type="discrete"
gecko_pref="layout.css.image-orientation.enabled"
spec="https://drafts.csswg.org/css-images/#propdef-image-orientation, \
/// additional values in https://developer.mozilla.org/en-US/docs/Web/CSS/image-orientation">
use std::fmt;
use style_traits::ToCss;
use values::specified::Angle;
use std::f64::consts::PI;
const TWO_PI: f64 = 2.0 * PI;
#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq)]
pub struct SpecifiedValue {
pub angle: Option<Angle>,
pub flipped: bool
}
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
if let Some(angle) = self.angle {
angle.to_css(dest)?;
if self.flipped {
dest.write_str(" flip")
} else {
Ok(())
}
} else {
if self.flipped {
dest.write_str("flip")
} else {
dest.write_str("from-image")
}
}
}
}
pub mod computed_value {
use std::fmt;
use style_traits::ToCss;
use values::specified::Angle;
#[derive(Clone, Copy, Debug, Eq, MallocSizeOf, PartialEq)]
pub enum Orientation {
Angle0 = 0,
Angle90,
Angle180,
Angle270,
}
impl Orientation {
pub fn angle(&self) -> Angle {
match *self {
Orientation::Angle0 => Angle::from_degrees(0.0, false),
Orientation::Angle90 => Angle::from_degrees(90.0, false),
Orientation::Angle180 => Angle::from_degrees(180.0, false),
Orientation::Angle270 => Angle::from_degrees(270.0, false),
}
}
}
impl ToCss for Orientation {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
// Should agree with Angle::to_css.
match *self {
Orientation::Angle0 => dest.write_str("0deg"),
Orientation::Angle90 => dest.write_str("90deg"),
Orientation::Angle180 => dest.write_str("180deg"),
Orientation::Angle270 => dest.write_str("270deg"),
}
}
}
#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq)]
pub enum T {
FromImage,
AngleWithFlipped(Orientation, bool),
}
}
use self::computed_value::Orientation;
#[inline]
pub fn get_initial_value() -> computed_value::T {
computed_value::T::AngleWithFlipped(Orientation::Angle0, false)
}
// According to CSS Content Module Level 3:
// The computed value of the property is calculated by rounding the specified angle
// to the nearest quarter-turn, rounding away from 0, then moduloing the value by 1 turn.
// This mirrors the Gecko implementation in
// nsStyleImageOrientation::CreateAsAngleAndFlip.
#[inline]
fn orientation_of_angle(angle: &computed::Angle) -> Orientation {
// Note that `angle` can be negative.
let mut rounded_angle = angle.radians64() % TWO_PI;
if rounded_angle < 0.0 {
// This computation introduces rounding error. Gecko previously
// didn't handle the negative case correctly; by branching we can
// match Gecko's behavior when it was correct.
rounded_angle = rounded_angle + TWO_PI;
}
if rounded_angle < 0.25 * PI {
return Orientation::Angle0
}
if rounded_angle < 0.75 * PI {
return Orientation::Angle90
}
if rounded_angle < 1.25 * PI {
return Orientation::Angle180
}
if rounded_angle < 1.75 * PI {
return Orientation::Angle270
}
Orientation::Angle0
}
impl ToComputedValue for SpecifiedValue {
type ComputedValue = computed_value::T;
#[inline]
fn to_computed_value(&self, context: &Context) -> computed_value::T {
if let Some(ref angle) = self.angle {
let angle = angle.to_computed_value(context);
let orientation = orientation_of_angle(&angle);
computed_value::T::AngleWithFlipped(orientation, self.flipped)
} else {
if self.flipped {
computed_value::T::AngleWithFlipped(Orientation::Angle0, true)
} else {
computed_value::T::FromImage
}
}
}
#[inline]
fn from_computed_value(computed: &computed_value::T) -> Self {
match *computed {
computed_value::T::FromImage => SpecifiedValue { angle: None, flipped: false },
computed_value::T::AngleWithFlipped(ref orientation, flipped) => {
SpecifiedValue {
angle: Some(orientation.angle()),
flipped: flipped,
}
}
}
}
}
impl ToCss for computed_value::T {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match *self {
computed_value::T::FromImage => dest.write_str("from-image"),
computed_value::T::AngleWithFlipped(angle, flipped) => {
angle.to_css(dest)?;
if flipped {
dest.write_str(" flip")?;
}
Ok(())
},
}
}
}
// from-image | <angle> | [<angle>? flip]
pub fn parse<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
-> Result<SpecifiedValue, ParseError<'i>> {
if input.try(|input| input.expect_ident_matching("from-image")).is_ok() {
// Handle from-image
Ok(SpecifiedValue { angle: None, flipped: false })
} else if input.try(|input| input.expect_ident_matching("flip")).is_ok() {
// Handle flip
Ok(SpecifiedValue { angle: Some(Angle::zero()), flipped: true })
} else {
// Handle <angle> | <angle> flip
let angle = input.try(|input| Angle::parse(context, input)).ok();
if angle.is_none() {
return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError));
}
let flipped = input.try(|input| input.expect_ident_matching("flip")).is_ok();
Ok(SpecifiedValue { angle: angle, flipped: flipped })
}
}
</%helpers:longhand>
${helpers.predefined_type("image-orientation",
"ImageOrientation",
"computed::ImageOrientation::zero()",
products="gecko",
animation_value_type="discrete",
gecko_pref="layout.css.image-orientation.enabled",
spec="https://drafts.csswg.org/css-images/#propdef-image-orientation, \
/// additional values in https://developer.mozilla.org/en-US/docs/Web/CSS/image-orientation")}