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

Upgrade to rustc 551a74dddd84cf01440ee84148ebd18bc68bd7c8.

Browse source
This commit is contained in:
Simon Sapin 2015-04-23 00:14:02 +02:00 • committed by Josh Matthews
parent 7b87085c18
commit ef8edd4e87
168 changed files with 2247 additions and 2408 deletions
Download patch file Download diff file Expand all files Collapse all files

5
components/style/Cargo.toml
View file

@ -18,9 +18,6 @@ path = "../util"
[dependencies.geom]
git = "https://github.com/servo/rust-geom"
[dependencies.cssparser]
git = "https://github.com/servo/rust-cssparser"
[dependencies.selectors]
git = "https://github.com/servo/rust-selectors"
@ -34,10 +31,10 @@ git = "https://github.com/servo/string-cache"
git = "https://github.com/servo/string-cache"
[dependencies]
text_writer = "0.1.1"
encoding = "0.2"
rustc-serialize = "0.3"
matches = "0.1"
url = "0.2.16"
mod_path = "0.1"
bitflags = "*"
cssparser = "0.3.1"

89
components/style/animation.rs
View file

@ -21,10 +21,8 @@ use values::computed::{LengthOrPercentageOrAuto, LengthOrPercentageOrNone, Lengt
use values::CSSFloat;
use cssparser::{RGBA, Color};
use std::num::Float;
use std::cmp::Ordering;
use std::iter::repeat;
use std::num::FromPrimitive;
use util::bezier::Bezier;
use util::geometry::Au;
@ -155,7 +153,7 @@ impl PropertyAnimation {
}
}
pub fn update(&self, style: &mut ComputedValues, time: f64) {
pub fn update(&self, style: &mut ComputedValues, time: f32) {
let progress = match self.timing_function {
TransitionTimingFunction::CubicBezier(p1, p2) => {
// See `WebCore::AnimationBase::solveEpsilon(double)` in WebKit.
@ -163,10 +161,10 @@ impl PropertyAnimation {
Bezier::new(p1, p2).solve(time, epsilon)
}
TransitionTimingFunction::Steps(steps, StartEnd::Start) => {
(time * (steps as f64)).ceil() / (steps as f64)
(time * (steps as f32)).ceil() / (steps as f32)
}
TransitionTimingFunction::Steps(steps, StartEnd::End) => {
(time * (steps as f64)).floor() / (steps as f64)
(time * (steps as f32)).floor() / (steps as f32)
}
};
@ -336,19 +334,19 @@ impl AnimatedProperty {
}
trait Interpolate {
fn interpolate(&self, other: &Self, time: f64) -> Option<Self>;
fn interpolate(&self, other: &Self, time: f32) -> Option<Self>;
}
impl Interpolate for Au {
#[inline]
fn interpolate(&self, other: &Au, time: f64) -> Option<Au> {
Some(Au((self.0 as f64 + (other.0 as f64 - self.0 as f64) * time).round() as i32))
fn interpolate(&self, other: &Au, time: f32) -> Option<Au> {
Some(Au((self.0 as f32 + (other.0 as f32 - self.0 as f32) * time).round() as i32))
}
}
impl <T> Interpolate for Option<T> where T:Interpolate {
#[inline]
fn interpolate(&self, other: &Option<T>, time: f64) -> Option<Option<T>> {
fn interpolate(&self, other: &Option<T>, time: f32) -> Option<Option<T>> {
match (self, other) {
(&Some(ref this), &Some(ref other)) => {
this.interpolate(other, time).and_then(|value| {
@ -360,32 +358,32 @@ impl <T> Interpolate for Option<T> where T:Interpolate {
}
}
impl Interpolate for f64 {
impl Interpolate for f32 {
#[inline]
fn interpolate(&self, other: &f64, time: f64) -> Option<f64> {
fn interpolate(&self, other: &f32, time: f32) -> Option<f32> {
Some(*self + (*other - *self) * time)
}
}
impl Interpolate for f32 {
impl Interpolate for f64 {
#[inline]
fn interpolate(&self, other: &f32, time: f64) -> Option<f32> {
Some(*self + (*other - *self) * (time as f32))
fn interpolate(&self, other: &f64, time: f32) -> Option<f64> {
Some(*self + (*other - *self) * (time as f64))
}
}
impl Interpolate for i32 {
#[inline]
fn interpolate(&self, other: &i32, time: f64) -> Option<i32> {
let a = *self as f64;
let b = *other as f64;
fn interpolate(&self, other: &i32, time: f32) -> Option<i32> {
let a = *self as f32;
let b = *other as f32;
Some((a + (b - a) * time).round() as i32)
}
}
impl Interpolate for Visibility {
#[inline]
fn interpolate(&self, other: &Visibility, time: f64)
fn interpolate(&self, other: &Visibility, time: f32)
-> Option<Visibility> {
match (*self, *other) {
(Visibility::visible, _) | (_, Visibility::visible) => {
@ -404,7 +402,7 @@ impl Interpolate for Visibility {
impl Interpolate for ZIndex {
#[inline]
fn interpolate(&self, other: &ZIndex, time: f64)
fn interpolate(&self, other: &ZIndex, time: f32)
-> Option<ZIndex> {
match (*self, *other) {
(ZIndex::Number(ref this),
@ -420,7 +418,7 @@ impl Interpolate for ZIndex {
impl Interpolate for VerticalAlign {
#[inline]
fn interpolate(&self, other: &VerticalAlign, time: f64)
fn interpolate(&self, other: &VerticalAlign, time: f32)
-> Option<VerticalAlign> {
match (*self, *other) {
(VerticalAlign::Length(ref this),
@ -436,7 +434,7 @@ impl Interpolate for VerticalAlign {
impl Interpolate for BorderSpacing {
#[inline]
fn interpolate(&self, other: &BorderSpacing, time: f64)
fn interpolate(&self, other: &BorderSpacing, time: f32)
-> Option<BorderSpacing> {
self.horizontal.interpolate(&other.horizontal, time).and_then(|horizontal| {
self.vertical.interpolate(&other.vertical, time).and_then(|vertical| {
@ -448,7 +446,7 @@ impl Interpolate for BorderSpacing {
impl Interpolate for RGBA {
#[inline]
fn interpolate(&self, other: &RGBA, time: f64) -> Option<RGBA> {
fn interpolate(&self, other: &RGBA, time: f32) -> Option<RGBA> {
match (self.red.interpolate(&other.red, time),
self.green.interpolate(&other.green, time),
self.blue.interpolate(&other.blue, time),
@ -463,7 +461,7 @@ impl Interpolate for RGBA {
impl Interpolate for Color {
#[inline]
fn interpolate(&self, other: &Color, time: f64) -> Option<Color> {
fn interpolate(&self, other: &Color, time: f32) -> Option<Color> {
match (*self, *other) {
(Color::RGBA(ref this), Color::RGBA(ref other)) => {
this.interpolate(other, time).and_then(|value| {
@ -477,7 +475,7 @@ impl Interpolate for Color {
impl Interpolate for LengthOrPercentage {
#[inline]
fn interpolate(&self, other: &LengthOrPercentage, time: f64)
fn interpolate(&self, other: &LengthOrPercentage, time: f32)
-> Option<LengthOrPercentage> {
match (*self, *other) {
(LengthOrPercentage::Length(ref this),
@ -499,7 +497,7 @@ impl Interpolate for LengthOrPercentage {
impl Interpolate for LengthOrPercentageOrAuto {
#[inline]
fn interpolate(&self, other: &LengthOrPercentageOrAuto, time: f64)
fn interpolate(&self, other: &LengthOrPercentageOrAuto, time: f32)
-> Option<LengthOrPercentageOrAuto> {
match (*self, *other) {
(LengthOrPercentageOrAuto::Length(ref this),
@ -524,7 +522,7 @@ impl Interpolate for LengthOrPercentageOrAuto {
impl Interpolate for LengthOrPercentageOrNone {
#[inline]
fn interpolate(&self, other: &LengthOrPercentageOrNone, time: f64)
fn interpolate(&self, other: &LengthOrPercentageOrNone, time: f32)
-> Option<LengthOrPercentageOrNone> {
match (*self, *other) {
(LengthOrPercentageOrNone::Length(ref this),
@ -549,7 +547,7 @@ impl Interpolate for LengthOrPercentageOrNone {
impl Interpolate for LineHeight {
#[inline]
fn interpolate(&self, other: &LineHeight, time: f64)
fn interpolate(&self, other: &LineHeight, time: f32)
-> Option<LineHeight> {
match (*self, *other) {
(LineHeight::Length(ref this),
@ -572,20 +570,39 @@ impl Interpolate for LineHeight {
}
}
/// http://dev.w3.org/csswg/css-transitions/#animtype-font-weight
impl Interpolate for FontWeight {
#[inline]
fn interpolate(&self, other: &FontWeight, time: f64)
fn interpolate(&self, other: &FontWeight, time: f32)
-> Option<FontWeight> {
let a = (*self as isize) as f64;
let b = (*other as isize) as f64;
let weight: Option<FontWeight> = FromPrimitive::from_isize((a + (b - a) * time).round() as isize);
weight
let a = (*self as u32) as f32;
let b = (*other as u32) as f32;
let weight = a + (b - a) * time;
Some(if weight < 150. {
FontWeight::Weight100
} else if weight < 250. {
FontWeight::Weight200
} else if weight < 350. {
FontWeight::Weight300
} else if weight < 450. {
FontWeight::Weight400
} else if weight < 550. {
FontWeight::Weight500
} else if weight < 650. {
FontWeight::Weight600
} else if weight < 750. {
FontWeight::Weight700
} else if weight < 850. {
FontWeight::Weight800
} else {
FontWeight::Weight900
})
}
}
impl Interpolate for ClipRect {
#[inline]
fn interpolate(&self, other: &ClipRect, time: f64)
fn interpolate(&self, other: &ClipRect, time: f32)
-> Option<ClipRect> {
match (self.top.interpolate(&other.top, time),
self.right.interpolate(&other.right, time),
@ -601,7 +618,7 @@ impl Interpolate for ClipRect {
impl Interpolate for BackgroundPosition {
#[inline]
fn interpolate(&self, other: &BackgroundPosition, time: f64)
fn interpolate(&self, other: &BackgroundPosition, time: f32)
-> Option<BackgroundPosition> {
match (self.horizontal.interpolate(&other.horizontal, time),
self.vertical.interpolate(&other.vertical, time)) {
@ -615,7 +632,7 @@ impl Interpolate for BackgroundPosition {
impl Interpolate for TextShadow {
#[inline]
fn interpolate(&self, other: &TextShadow, time: f64)
fn interpolate(&self, other: &TextShadow, time: f32)
-> Option<TextShadow> {
match (self.offset_x.interpolate(&other.offset_x, time),
self.offset_y.interpolate(&other.offset_y, time),
@ -631,7 +648,7 @@ impl Interpolate for TextShadow {
impl Interpolate for TextShadowList {
#[inline]
fn interpolate(&self, other: &TextShadowList, time: f64)
fn interpolate(&self, other: &TextShadowList, time: f32)
-> Option<TextShadowList> {
let zero = TextShadow {
offset_x: Au(0),

2
components/style/build.rs
View file

@ -2,8 +2,6 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#![feature(io, path)]
use std::env;
use std::fs::File;
use std::io::Write;

26
components/style/legacy.rs
View file

@ -16,8 +16,8 @@ use properties::PropertyDeclaration;
use properties::longhands::{self, border_spacing};
use selector_matching::Stylist;
use selectors::smallvec::VecLike;
use util::geometry::Au;
use util::smallvec::VecLike;
use util::str::LengthOrPercentageOrAuto;
/// Legacy presentational attributes that take a length as defined in HTML5 § 2.4.4.4.
@ -88,9 +88,9 @@ impl PresentationalHintSynthesis for Stylist {
V: VecLike<DeclarationBlock<Vec<PropertyDeclaration>>> {
let element = node.as_element();
let length = matching_rules_list.vec_len();
let length = matching_rules_list.len();
element.synthesize_presentational_hints_for_legacy_attributes(matching_rules_list);
if matching_rules_list.vec_len() != length {
if matching_rules_list.len() != length {
// Never share style for elements with preshints
*shareable = false;
}
@ -101,13 +101,13 @@ impl PresentationalHintSynthesis for Stylist {
LengthOrPercentageOrAuto::Auto => {}
LengthOrPercentageOrAuto::Percentage(percentage) => {
let width_value = specified::LengthOrPercentageOrAuto::Percentage(percentage);
matching_rules_list.vec_push(from_declaration(
matching_rules_list.push(from_declaration(
PropertyDeclaration::Width(SpecifiedValue(width_value))));
*shareable = false
}
LengthOrPercentageOrAuto::Length(length) => {
let width_value = specified::LengthOrPercentageOrAuto::Length(specified::Length::Absolute(length));
matching_rules_list.vec_push(from_declaration(
matching_rules_list.push(from_declaration(
PropertyDeclaration::Width(SpecifiedValue(width_value))));
*shareable = false
}
@ -127,7 +127,7 @@ impl PresentationalHintSynthesis for Stylist {
None => {}
Some(length) => {
let width_value = specified::Length::Absolute(Au::from_px(length as isize));
matching_rules_list.vec_push(from_declaration(
matching_rules_list.push(from_declaration(
PropertyDeclaration::BorderSpacing(
SpecifiedValue(
border_spacing::SpecifiedValue {
@ -146,7 +146,7 @@ impl PresentationalHintSynthesis for Stylist {
Some(value) if value != 0 => {
let value = specified::Length::ServoCharacterWidth(
specified::CharacterWidth(value));
matching_rules_list.vec_push(from_declaration(
matching_rules_list.push(from_declaration(
PropertyDeclaration::Width(SpecifiedValue(
specified::LengthOrPercentageOrAuto::Length(value)))));
*shareable = false
@ -166,7 +166,7 @@ impl PresentationalHintSynthesis for Stylist {
//
// https://html.spec.whatwg.org/multipage/#textarea-effective-width
let value = specified::Length::ServoCharacterWidth(specified::CharacterWidth(value));
matching_rules_list.vec_push(from_declaration(
matching_rules_list.push(from_declaration(
PropertyDeclaration::Width(SpecifiedValue(
specified::LengthOrPercentageOrAuto::Length(value)))));
*shareable = false
@ -179,7 +179,7 @@ impl PresentationalHintSynthesis for Stylist {
//
// https://html.spec.whatwg.org/multipage/#textarea-effective-height
let value = specified::Length::FontRelative(specified::FontRelativeLength::Em(value as CSSFloat));
matching_rules_list.vec_push(from_declaration(
matching_rules_list.push(from_declaration(
PropertyDeclaration::Height(SpecifiedValue(
longhands::height::SpecifiedValue(
specified::LengthOrPercentageOrAuto::Length(value))))));
@ -205,16 +205,16 @@ impl PresentationalHintSynthesis for Stylist {
None => {}
Some(length) => {
let width_value = specified::Length::Absolute(Au::from_px(length as isize));
matching_rules_list.vec_push(from_declaration(
matching_rules_list.push(from_declaration(
PropertyDeclaration::BorderTopWidth(SpecifiedValue(
longhands::border_top_width::SpecifiedValue(width_value)))));
matching_rules_list.vec_push(from_declaration(
matching_rules_list.push(from_declaration(
PropertyDeclaration::BorderLeftWidth(SpecifiedValue(
longhands::border_left_width::SpecifiedValue(width_value)))));
matching_rules_list.vec_push(from_declaration(
matching_rules_list.push(from_declaration(
PropertyDeclaration::BorderBottomWidth(SpecifiedValue(
longhands::border_bottom_width::SpecifiedValue(width_value)))));
matching_rules_list.vec_push(from_declaration(
matching_rules_list.push(from_declaration(
PropertyDeclaration::BorderRightWidth(SpecifiedValue(
longhands::border_right_width::SpecifiedValue(width_value)))));
*shareable = false

3
components/style/lib.rs
View file

@ -18,7 +18,6 @@
extern crate collections;
extern crate geom;
extern crate text_writer;
extern crate url;
#[macro_use]
@ -28,7 +27,7 @@ extern crate cssparser;
extern crate matches;
extern crate encoding;
extern crate "rustc-serialize" as rustc_serialize;
extern crate rustc_serialize;
extern crate string_cache;
extern crate selectors;

2
components/style/node.rs
View file

@ -7,10 +7,10 @@
use legacy::{IntegerAttribute, LengthAttribute, UnsignedIntegerAttribute};
use properties::PropertyDeclaration;
use util::smallvec::VecLike;
use util::str::LengthOrPercentageOrAuto;
use selectors::matching::DeclarationBlock;
use selectors::smallvec::VecLike;
pub use selectors::tree::{TNode, TElement};
pub trait TElementAttributes : Copy {

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

@ -232,10 +232,10 @@ pub mod longhands {
use values::computed::{ToComputedValue, Context};
use util::geometry::Au;
use cssparser::ToCss;
use text_writer::{self, TextWriter};
use std::fmt;
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
self.0.to_css(dest)
}
}
@ -384,7 +384,7 @@ pub mod longhands {
pub type SpecifiedValue = computed_value::T;
pub mod computed_value {
use cssparser::ToCss;
use text_writer::{self, TextWriter};
use std::fmt;
#[derive(PartialEq, Clone, Eq, Copy, Debug)]
pub enum T {
@ -393,7 +393,7 @@ pub mod longhands {
}
impl ToCss for T {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match self {
&T::Auto => dest.write_str("auto"),
&T::Number(number) => write!(dest, "{}", number),
@ -437,10 +437,10 @@ pub mod longhands {
<%self:longhand name="height">
use values::computed::{ToComputedValue, Context};
use cssparser::ToCss;
use text_writer::{self, TextWriter};
use std::fmt;
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
self.0.to_css(dest)
}
}
@ -493,7 +493,7 @@ pub mod longhands {
<%self:longhand name="line-height">
use values::computed::{ToComputedValue, Context};
use cssparser::ToCss;
use text_writer::{self, TextWriter};
use std::fmt;
use values::CSSFloat;
#[derive(Clone, PartialEq, Copy)]
@ -505,7 +505,7 @@ pub mod longhands {
}
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match self {
&SpecifiedValue::Normal => dest.write_str("normal"),
&SpecifiedValue::Length(length) => length.to_css(dest),
@ -583,7 +583,7 @@ pub mod longhands {
<%self:longhand name="vertical-align">
use values::computed::{ToComputedValue, Context};
use cssparser::ToCss;
use text_writer::{self, TextWriter};
use std::fmt;
<% vertical_align_keywords = (
"baseline sub super top text-top middle bottom text-bottom".split()) %>
@ -597,7 +597,7 @@ pub mod longhands {
}
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match self {
% for keyword in vertical_align_keywords:
&SpecifiedValue::${to_rust_ident(keyword)} => dest.write_str("${keyword}"),
@ -716,12 +716,12 @@ pub mod longhands {
use values::computed::{Context, ToComputedValue};
use cssparser::ToCss;
use text_writer::{self, TextWriter};
use std::fmt;
pub use self::computed_value::T as SpecifiedValue;
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
self.0.to_css(dest)
}
}
@ -778,7 +778,7 @@ pub mod longhands {
use super::super::list_style_type;
use cssparser::{self, ToCss};
use text_writer::{self, TextWriter};
use std::fmt;
#[derive(PartialEq, Eq, Clone)]
pub enum ContentItem {
@ -799,7 +799,7 @@ pub mod longhands {
}
impl ToCss for ContentItem {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match self {
&ContentItem::String(ref s) => {
cssparser::serialize_string(&**s, dest)
@ -837,7 +837,7 @@ pub mod longhands {
}
impl ToCss for T {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match self {
&T::normal => dest.write_str("normal"),
&T::none => dest.write_str("none"),
@ -943,10 +943,9 @@ pub mod longhands {
""")}
<%self:longhand name="list-style-image">
use std::borrow::IntoCow;
use url::Url;
use cssparser::{ToCss, Token};
use text_writer::{self, TextWriter};
use std::fmt;
use values::computed::{ToComputedValue, Context};
#[derive(Clone, PartialEq, Eq)]
@ -956,11 +955,11 @@ pub mod longhands {
}
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match *self {
SpecifiedValue::None => dest.write_str("none"),
SpecifiedValue::Url(ref url) => {
Token::Url(url.to_string().into_cow()).to_css(dest)
Token::Url(url.to_string().into()).to_css(dest)
}
}
}
@ -997,11 +996,11 @@ pub mod longhands {
</%self:longhand>
<%self:longhand name="quotes">
use text_writer::{self, TextWriter};
use std::fmt;
use values::computed::ComputedValueAsSpecified;
use std::borrow::Cow;
use cssparser::{ToCss, Token};
use std::borrow::IntoCow;
pub use self::computed_value::T as SpecifiedValue;
@ -1013,16 +1012,16 @@ pub mod longhands {
impl ComputedValueAsSpecified for SpecifiedValue {}
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
let mut first = true;
for pair in self.0.iter() {
if !first {
try!(dest.write_str(" "));
}
first = false;
try!(Token::QuotedString((*pair.0).into_cow()).to_css(dest));
try!(Token::QuotedString(Cow::from(&*pair.0)).to_css(dest));
try!(dest.write_str(" "));
try!(Token::QuotedString((*pair.1).into_cow()).to_css(dest));
try!(Token::QuotedString(Cow::from(&*pair.1)).to_css(dest));
}
Ok(())
}
@ -1066,11 +1065,11 @@ pub mod longhands {
<%self:longhand name="counter-increment">
use super::content;
use text_writer::{self, TextWriter};
use std::fmt;
use values::computed::ComputedValueAsSpecified;
use cssparser::{ToCss, Token};
use std::borrow::{IntoCow, ToOwned};
use std::borrow::{Cow, ToOwned};
pub use self::computed_value::T as SpecifiedValue;
@ -1087,15 +1086,15 @@ pub mod longhands {
impl ComputedValueAsSpecified for SpecifiedValue {}
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
let mut first = true;
for pair in self.0.iter() {
if !first {
try!(dest.write_str(" "));
}
first = false;
try!(Token::QuotedString(pair.0.as_slice().into_cow()).to_css(dest));
try!(dest.write_str(format!(" {}", pair.1).as_slice()));
try!(Token::QuotedString(Cow::from(&*pair.0)).to_css(dest));
try!(write!(dest, " {}", pair.1));
}
Ok(())
}
@ -1145,7 +1144,7 @@ pub mod longhands {
use values::specified::Image;
use values::computed::{ToComputedValue, Context};
use cssparser::ToCss;
use text_writer::{self, TextWriter};
use std::fmt;
pub mod computed_value {
use values::computed;
@ -1156,7 +1155,7 @@ pub mod longhands {
pub struct SpecifiedValue(pub Option<Image>);
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match *self {
SpecifiedValue(Some(ref image)) => image.to_css(dest),
SpecifiedValue(None) => dest.write_str("none"),
@ -1190,7 +1189,7 @@ pub mod longhands {
<%self:longhand name="background-position">
use cssparser::ToCss;
use text_writer::{self, TextWriter};
use std::fmt;
use values::computed::{ToComputedValue, Context};
pub mod computed_value {
@ -1210,7 +1209,7 @@ pub mod longhands {
}
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
try!(self.horizontal.to_css(dest));
try!(dest.write_str(" "));
try!(self.vertical.to_css(dest));
@ -1300,7 +1299,7 @@ pub mod longhands {
<%self:longhand name="background-size">
use cssparser::{ToCss, Token};
use std::ascii::AsciiExt;
use text_writer::{self, TextWriter};
use std::fmt;
use values::computed::{Context, ToComputedValue};
pub mod computed_value {
@ -1327,7 +1326,7 @@ pub mod longhands {
}
impl ToCss for SpecifiedExplicitSize {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
try!(self.width.to_css(dest));
try!(dest.write_str(" "));
self.height.to_css(dest)
@ -1342,7 +1341,7 @@ pub mod longhands {
}
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match *self {
SpecifiedValue::Explicit(ref size) => size.to_css(dest),
SpecifiedValue::Cover => dest.write_str("cover"),
@ -1461,12 +1460,13 @@ pub mod longhands {
use self::computed_value::FontFamily;
use string_cache::Atom;
use values::computed::ComputedValueAsSpecified;
pub use self::computed_value::T as SpecifiedValue;
impl ComputedValueAsSpecified for SpecifiedValue {}
pub mod computed_value {
use cssparser::ToCss;
use string_cache::Atom;
use text_writer::{self, TextWriter};
use std::fmt;
#[derive(PartialEq, Eq, Clone, Hash)]
pub enum FontFamily {
@ -1487,15 +1487,15 @@ pub mod longhands {
}
}
impl ToCss for FontFamily {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match self {
&FontFamily::FamilyName(ref name) => dest.write_str(name.as_slice()),
}
}
}
impl ToCss for Vec<FontFamily> {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
let mut iter = self.iter();
impl ToCss for T {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
let mut iter = self.0.iter();
try!(iter.next().unwrap().to_css(dest));
for family in iter {
try!(dest.write_str(", "));
@ -1504,23 +1504,23 @@ pub mod longhands {
Ok(())
}
}
pub type T = Vec<FontFamily>;
#[derive(Clone, PartialEq, Eq, Hash)]
pub struct T(pub Vec<FontFamily>);
}
pub type SpecifiedValue = computed_value::T;
#[inline]
pub fn get_initial_value() -> computed_value::T {
vec![FontFamily::FamilyName(Atom::from_slice("serif"))]
computed_value::T(vec![FontFamily::FamilyName(Atom::from_slice("serif"))])
}
/// <family-name>#
/// <family-name> = <string> | [ <ident>+ ]
/// TODO: <generic-family>
pub fn parse(_context: &ParserContext, input: &mut Parser) -> Result<SpecifiedValue, ()> {
input.parse_comma_separated(parse_one_family)
input.parse_comma_separated(parse_one_family).map(SpecifiedValue)
}
pub fn parse_one_family(input: &mut Parser) -> Result<FontFamily, ()> {
if let Ok(value) = input.try(|input| input.expect_string()) {
return Ok(FontFamily::FamilyName(Atom::from_slice(value.as_slice())))
return Ok(FontFamily::FamilyName(Atom::from_slice(&value)))
}
let first_ident = try!(input.expect_ident());
// match_ignore_ascii_case! { first_ident,
@ -1536,7 +1536,7 @@ pub mod longhands {
value.push_str(" ");
value.push_str(&ident);
}
Ok(FontFamily::FamilyName(Atom::from_slice(value.as_slice())))
Ok(FontFamily::FamilyName(Atom::from_slice(&value)))
}
</%self:longhand>
@ -1546,7 +1546,7 @@ pub mod longhands {
<%self:longhand name="font-weight">
use cssparser::ToCss;
use text_writer::{self, TextWriter};
use std::fmt;
use values::computed::{ToComputedValue, Context};
#[derive(Clone, PartialEq, Eq, Copy)]
@ -1559,7 +1559,7 @@ pub mod longhands {
}
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match self {
&SpecifiedValue::Bolder => dest.write_str("bolder"),
&SpecifiedValue::Lighter => dest.write_str("lighter"),
@ -1596,7 +1596,7 @@ pub mod longhands {
}
pub mod computed_value {
use std::fmt;
#[derive(PartialEq, Eq, Copy, Clone, Hash, FromPrimitive)]
#[derive(PartialEq, Eq, Copy, Clone, Hash)]
pub enum T {
% for weight in range(100, 901, 100):
Weight${weight} = ${weight},
@ -1667,10 +1667,10 @@ pub mod longhands {
use util::geometry::Au;
use values::computed::{ToComputedValue, Context};
use cssparser::ToCss;
use text_writer::{self, TextWriter};
use std::fmt;
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
self.0.to_css(dest)
}
}
@ -1730,12 +1730,59 @@ pub mod longhands {
${new_style_struct("InheritedText", is_inherited=True)}
${single_keyword("text-align", "start end left right center justify")}
<%self:longhand name="text-align">
pub use self::computed_value::T as SpecifiedValue;
use values::computed::ComputedValueAsSpecified;
impl ComputedValueAsSpecified for SpecifiedValue {}
pub mod computed_value {
macro_rules! define_text_align {
( $( $name: ident => $discriminant: expr, )+ ) => {
define_css_keyword_enum! { T:
$(
stringify!($name) => $name,
)+
}
impl T {
pub fn to_u32(self) -> u32 {
match self {
$(
T::$name => $discriminant,
)+
}
}
pub fn from_u32(discriminant: u32) -> Option<T> {
match discriminant {
$(
$discriminant => Some(T::$name),
)+
_ => None
}
}
}
}
}
define_text_align! {
start => 0,
end => 1,
left => 2,
right => 3,
center => 4,
justify => 5,
}
}
#[inline] pub fn get_initial_value() -> computed_value::T {
computed_value::T::start
}
pub fn parse(_context: &ParserContext, input: &mut Parser)
-> Result<SpecifiedValue, ()> {
computed_value::T::parse(input)
}
</%self:longhand>
<%self:longhand name="letter-spacing">
use values::computed::{ToComputedValue, Context};
use cssparser::ToCss;
use text_writer::{self, TextWriter};
use std::fmt;
#[derive(Clone, Copy, PartialEq)]
pub enum SpecifiedValue {
@ -1744,7 +1791,7 @@ pub mod longhands {
}
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match *self {
SpecifiedValue::Normal => dest.write_str("normal"),
SpecifiedValue::Specified(l) => l.to_css(dest),
@ -1786,7 +1833,7 @@ pub mod longhands {
<%self:longhand name="word-spacing">
use values::computed::{ToComputedValue, Context};
use cssparser::ToCss;
use text_writer::{self, TextWriter};
use std::fmt;
#[derive(Clone, Copy, PartialEq)]
pub enum SpecifiedValue {
@ -1795,7 +1842,7 @@ pub mod longhands {
}
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match *self {
SpecifiedValue::Normal => dest.write_str("normal"),
SpecifiedValue::Specified(l) => l.to_css(dest),
@ -1852,7 +1899,7 @@ pub mod longhands {
<%self:longhand name="text-decoration">
use cssparser::ToCss;
use text_writer::{self, TextWriter};
use std::fmt;
use values::computed::ComputedValueAsSpecified;
impl ComputedValueAsSpecified for SpecifiedValue {}
@ -1867,7 +1914,7 @@ pub mod longhands {
}
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
let mut space = false;
if self.underline {
try!(dest.write_str("underline"));
@ -2030,7 +2077,7 @@ pub mod longhands {
use values::computed::{Context, ToComputedValue};
use cssparser::ToCss;
use text_writer::{self, TextWriter};
use std::fmt;
use util::geometry::Au;
pub mod computed_value {
@ -2058,7 +2105,7 @@ pub mod longhands {
}
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
try!(self.horizontal.to_css(dest));
try!(dest.write_str(" "));
self.vertical.to_css(dest)
@ -2137,7 +2184,7 @@ pub mod longhands {
pub mod computed_value {
use cssparser::ToCss;
use text_writer::{self, TextWriter};
use std::fmt;
use util::cursor::Cursor;
#[derive(Clone, PartialEq, Eq, Copy, Debug)]
@ -2147,7 +2194,7 @@ pub mod longhands {
}
impl ToCss for T {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match *self {
T::AutoCursor => dest.write_str("auto"),
T::SpecifiedCursor(c) => c.to_css(dest),
@ -2183,7 +2230,7 @@ pub mod longhands {
<%self:longhand name="column-width" experimental="True">
use values::computed::{ToComputedValue, Context};
use cssparser::ToCss;
use text_writer::{self, TextWriter};
use std::fmt;
#[derive(Clone, Copy, PartialEq)]
pub enum SpecifiedValue {
@ -2192,7 +2239,7 @@ pub mod longhands {
}
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match *self {
SpecifiedValue::Auto => dest.write_str("auto"),
SpecifiedValue::Specified(l) => l.to_css(dest),
@ -2234,7 +2281,7 @@ pub mod longhands {
<%self:longhand name="column-count" experimental="True">
use values::computed::{ToComputedValue, Context};
use cssparser::ToCss;
use text_writer::{self, TextWriter};
use std::fmt;
#[derive(Clone, Copy, PartialEq)]
pub enum SpecifiedValue {
@ -2243,7 +2290,7 @@ pub mod longhands {
}
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match *self {
SpecifiedValue::Auto => dest.write_str("auto"),
SpecifiedValue::Specified(count) => write!(dest, "{}", count),
@ -2276,10 +2323,9 @@ pub mod longhands {
if input.try(|input| input.expect_ident_matching("auto")).is_ok() {
Ok(SpecifiedValue::Auto)
} else {
use std::u32;
let count = try!(input.expect_integer());
// Zero is invalid
if count <= 0 || count > (u32::MAX as i64) {
if count <= 0 {
return Err(())
}
Ok(SpecifiedValue::Specified(count as u32))
@ -2290,7 +2336,7 @@ pub mod longhands {
<%self:longhand name="column-gap" experimental="True">
use values::computed::{ToComputedValue, Context};
use cssparser::ToCss;
use text_writer::{self, TextWriter};
use std::fmt;
#[derive(Clone, Copy, PartialEq)]
pub enum SpecifiedValue {
@ -2299,7 +2345,7 @@ pub mod longhands {
}
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match *self {
SpecifiedValue::Normal => dest.write_str("normal"),
SpecifiedValue::Specified(l) => l.to_css(dest),
@ -2345,10 +2391,10 @@ pub mod longhands {
use values::CSSFloat;
use values::computed::{ToComputedValue, Context};
use cssparser::ToCss;
use text_writer::{self, TextWriter};
use std::fmt;
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
self.0.to_css(dest)
}
}
@ -2385,10 +2431,11 @@ pub mod longhands {
<%self:longhand name="box-shadow">
use cssparser::{self, ToCss};
use text_writer::{self, TextWriter};
use std::fmt;
use values::computed::{ToComputedValue, Context};
pub type SpecifiedValue = Vec<SpecifiedBoxShadow>;
#[derive(Clone, PartialEq)]
pub struct SpecifiedValue(Vec<SpecifiedBoxShadow>);
#[derive(Clone, PartialEq)]
pub struct SpecifiedBoxShadow {
@ -2400,9 +2447,9 @@ pub mod longhands {
pub inset: bool,
}
impl ToCss for Vec<SpecifiedBoxShadow> {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
let mut iter = self.iter();
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
let mut iter = self.0.iter();
if let Some(shadow) = iter.next() {
try!(shadow.to_css(dest));
} else {
@ -2418,7 +2465,7 @@ pub mod longhands {
}
impl ToCss for SpecifiedBoxShadow {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
if self.inset {
try!(dest.write_str("inset "));
}
@ -2474,9 +2521,9 @@ pub mod longhands {
pub fn parse(_context: &ParserContext, input: &mut Parser) -> Result<SpecifiedValue, ()> {
if input.try(|input| input.expect_ident_matching("none")).is_ok() {
Ok(Vec::new())
Ok(SpecifiedValue(Vec::new()))
} else {
input.parse_comma_separated(parse_one_box_shadow)
input.parse_comma_separated(parse_one_box_shadow).map(SpecifiedValue)
}
}
@ -2485,7 +2532,7 @@ pub mod longhands {
#[inline]
fn to_computed_value(&self, context: &Context) -> computed_value::T {
self.iter().map(|value| compute_one_box_shadow(value, context)).collect()
self.0.iter().map(|value| compute_one_box_shadow(value, context)).collect()
}
}
@ -2567,7 +2614,7 @@ pub mod longhands {
<%self:longhand name="clip">
use cssparser::ToCss;
use text_writer::{self, TextWriter};
use std::fmt;
// NB: `top` and `left` are 0 if `auto` per CSS 2.1 11.1.2.
@ -2595,10 +2642,11 @@ pub mod longhands {
pub left: specified::Length,
}
pub type SpecifiedValue = Option<SpecifiedClipRect>;
#[derive(Clone, Debug, PartialEq, Copy)]
pub struct SpecifiedValue(Option<SpecifiedClipRect>);
impl ToCss for SpecifiedClipRect {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
try!(dest.write_str("rect("));
try!(self.top.to_css(dest));
@ -2625,9 +2673,9 @@ pub mod longhands {
}
}
impl ToCss for Option<SpecifiedClipRect> {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
if let Some(ref rect) = *self {
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
if let Some(ref rect) = self.0 {
rect.to_css(dest)
} else {
dest.write_str("auto")
@ -2645,7 +2693,7 @@ pub mod longhands {
#[inline]
fn to_computed_value(&self, context: &Context) -> computed_value::T {
self.map(|value| computed_value::ClipRect {
self.0.map(|value| computed_value::ClipRect {
top: value.top.to_computed_value(context),
right: value.right.map(|right| right.to_computed_value(context)),
bottom: value.bottom.map(|bottom| bottom.to_computed_value(context)),
@ -2660,7 +2708,7 @@ pub mod longhands {
use values::specified::Length;
if input.try(|input| input.expect_ident_matching("auto")).is_ok() {
return Ok(None)
return Ok(SpecifiedValue(None))
}
if !try!(input.expect_function()).eq_ignore_ascii_case("rect") {
return Err(())
@ -2675,12 +2723,12 @@ pub mod longhands {
})
}));
if sides.len() == 4 {
Ok(Some(SpecifiedClipRect {
Ok(SpecifiedValue(Some(SpecifiedClipRect {
top: sides[0].unwrap_or(Length::Absolute(Au(0))),
right: sides[1],
bottom: sides[2],
left: sides[3].unwrap_or(Length::Absolute(Au(0))),
}))
})))
} else {
Err(())
}
@ -2690,7 +2738,6 @@ pub mod longhands {
<%self:longhand name="text-shadow">
use cssparser::{self, ToCss};
use std::fmt;
use text_writer::{self, TextWriter};
use values::computed::{Context, ToComputedValue};
@ -2736,7 +2783,7 @@ pub mod longhands {
}
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
let mut iter = self.0.iter();
if let Some(shadow) = iter.next() {
try!(shadow.to_css(dest));
@ -2753,7 +2800,7 @@ pub mod longhands {
}
impl ToCss for SpecifiedTextShadow {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
try!(self.offset_x.to_css(dest));
try!(dest.write_str(" "));
try!(self.offset_y.to_css(dest));
@ -2859,7 +2906,7 @@ pub mod longhands {
use values::specified::{Angle, Length};
use values::CSSFloat;
use cssparser::ToCss;
use text_writer::{self, TextWriter};
use std::fmt;
#[derive(Clone, PartialEq)]
pub struct SpecifiedValue(Vec<SpecifiedFilter>);
@ -2937,7 +2984,7 @@ pub mod longhands {
}
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
let mut iter = self.0.iter();
if let Some(filter) = iter.next() {
try!(filter.to_css(dest));
@ -2954,7 +3001,7 @@ pub mod longhands {
}
impl ToCss for SpecifiedFilter {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match *self {
SpecifiedFilter::Blur(value) => {
try!(dest.write_str("blur("));
@ -3047,16 +3094,15 @@ pub mod longhands {
use values::computed::{ToComputedValue, Context};
use cssparser::ToCss;
use std::f64;
use std::f32;
use std::ops::Mul;
use text_writer::{self, TextWriter};
use std::fmt;
use util::geometry::Au;
pub mod computed_value {
use values::CSSFloat;
use values::computed;
use std::num::Float;
use std::ops::Mul;
#[derive(Clone, Copy, Debug, PartialEq)]
@ -3148,8 +3194,8 @@ pub mod longhands {
m31: specified::LengthAndPercentage, m32: specified::LengthAndPercentage,
}
impl ToCss for Option<SpecifiedMatrix> {
fn to_css<W>(&self, _: &mut W) -> text_writer::Result where W: TextWriter {
impl ToCss for SpecifiedMatrix {
fn to_css<W>(&self, _: &mut W) -> fmt::Result where W: fmt::Write {
// TODO(pcwalton)
Ok(())
}
@ -3217,7 +3263,7 @@ pub mod longhands {
}
impl ToCss for SpecifiedOperation {
fn to_css<W>(&self, _: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, _: &mut W) -> fmt::Result where W: fmt::Write {
// TODO(pcwalton)
Ok(())
}
@ -3227,7 +3273,7 @@ pub mod longhands {
pub struct SpecifiedValue(Vec<SpecifiedOperation>);
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
let mut first = true;
for operation in self.0.iter() {
if !first {
@ -3267,8 +3313,8 @@ pub mod longhands {
return Err(())
}
let (tx, ty) =
(specified::Length::Absolute(Au::from_frac_px(values[4])),
specified::Length::Absolute(Au::from_frac_px(values[5])));
(specified::Length::Absolute(Au::from_frac32_px(values[4])),
specified::Length::Absolute(Au::from_frac32_px(values[5])));
let (tx, ty) =
(specified::LengthAndPercentage::from_length(tx),
specified::LengthAndPercentage::from_length(ty));
@ -3394,7 +3440,7 @@ pub mod longhands {
result.scale(sx, sy)
}
SpecifiedOperation::Rotate(ref theta) => {
result.rotate(f64::consts::PI_2 - theta.radians());
result.rotate(f32::consts::PI_2 - theta.radians());
}
SpecifiedOperation::Skew(sx, sy) => {
result.skew(sx, sy)
@ -3411,7 +3457,7 @@ pub mod longhands {
use values::specified::LengthOrPercentage;
use cssparser::ToCss;
use text_writer::{self, TextWriter};
use std::fmt;
pub mod computed_value {
use values::computed::LengthOrPercentage;
@ -3430,7 +3476,7 @@ pub mod longhands {
}
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
try!(self.horizontal.to_css(dest));
try!(dest.write_str(" "));
self.vertical.to_css(dest)
@ -3534,7 +3580,7 @@ pub mod longhands {
pub mod computed_value {
use cssparser::ToCss;
use text_writer::{self, TextWriter};
use std::fmt;
#[derive(Copy, Clone, Debug, PartialEq)]
pub enum T {
@ -3544,7 +3590,7 @@ pub mod longhands {
}
impl ToCss for T {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match *self {
T::Auto => dest.write_str("auto"),
T::CrispEdges => dest.write_str("crisp-edges"),
@ -3596,7 +3642,7 @@ pub mod longhands {
pub mod computed_value {
use cssparser::ToCss;
use text_writer::{self, TextWriter};
use std::fmt;
use values::computed::{Context, ToComputedValue};
pub use values::computed::Time as SingleComputedValue;
@ -3614,7 +3660,7 @@ pub mod longhands {
}
impl ToCss for T {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
if self.0.is_empty() {
return dest.write_str("none")
}
@ -3704,18 +3750,18 @@ pub mod longhands {
pub mod computed_value {
use cssparser::ToCss;
use geom::point::Point2D;
use text_writer::{self, TextWriter};
use std::fmt;
pub use self::TransitionTimingFunction as SingleComputedValue;
#[derive(Copy, Clone, Debug, PartialEq)]
pub enum TransitionTimingFunction {
CubicBezier(Point2D<f64>, Point2D<f64>),
CubicBezier(Point2D<f32>, Point2D<f32>),
Steps(u32, StartEnd),
}
impl ToCss for TransitionTimingFunction {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match *self {
TransitionTimingFunction::CubicBezier(p1, p2) => {
try!(dest.write_str("cubic-bezier("));
@ -3746,7 +3792,7 @@ pub mod longhands {
}
impl ToCss for StartEnd {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match *self {
StartEnd::Start => dest.write_str("start"),
StartEnd::End => dest.write_str("end"),
@ -3758,7 +3804,7 @@ pub mod longhands {
pub struct T(pub Vec<TransitionTimingFunction>);
impl ToCss for T {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
if self.0.is_empty() {
return dest.write_str("none")
}
@ -3857,7 +3903,7 @@ pub mod longhands {
pub mod computed_value {
use cssparser::ToCss;
use text_writer::{self, TextWriter};
use std::fmt;
pub use self::TransitionProperty as SingleComputedValue;
@ -3958,7 +4004,7 @@ pub mod longhands {
];
impl ToCss for TransitionProperty {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match *self {
TransitionProperty::All => dest.write_str("all"),
TransitionProperty::BackgroundColor => dest.write_str("background-color"),
@ -4013,7 +4059,7 @@ pub mod longhands {
pub struct T(pub Vec<SingleComputedValue>);
impl ToCss for T {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
if self.0.is_empty() {
return dest.write_str("none")
}
@ -4500,7 +4546,7 @@ pub mod shorthands {
font_weight: weight,
font_size: size,
line_height: line_height,
font_family: Some(family)
font_family: Some(font_family::SpecifiedValue(family))
})
</%self:shorthand>

6
components/style/selector_matching.rs
View file

@ -8,9 +8,9 @@ use selectors::bloom::BloomFilter;
use selectors::matching::{SelectorMap, Rule};
use selectors::matching::DeclarationBlock as GenericDeclarationBlock;
use selectors::parser::PseudoElement;
use selectors::smallvec::VecLike;
use selectors::tree::TNode;
use util::resource_files::read_resource_file;
use util::smallvec::VecLike;
use legacy::PresentationalHintSynthesis;
use media_queries::Device;
@ -213,7 +213,7 @@ impl Stylist {
// Step 4: Normal style attributes.
style_attribute.map(|sa| {
shareable = false;
applicable_declarations.vec_push(
applicable_declarations.push(
GenericDeclarationBlock::from_declarations(sa.normal.clone()))
});
@ -226,7 +226,7 @@ impl Stylist {
// Step 6: `!important` style attributes.
style_attribute.map(|sa| {
shareable = false;
applicable_declarations.vec_push(
applicable_declarations.push(
GenericDeclarationBlock::from_declarations(sa.important.clone()))
});

4
components/style/stylesheets.rs
View file

@ -18,7 +18,7 @@ use parser::{ParserContext, log_css_error};
use properties::{PropertyDeclarationBlock, parse_property_declaration_list};
use media_queries::{Device, MediaQueryList, parse_media_query_list};
use font_face::{FontFaceRule, parse_font_face_block};
use util::smallvec::{SmallVec, SmallVec2};
use util::smallvec::SmallVec2;
/// Each style rule has an origin, which determines where it enters the cascade.
@ -178,7 +178,7 @@ impl<'a> Iterator for Rules<'a> {
fn next(&mut self) -> Option<&'a CSSRule> {
while !self.stack.is_empty() {
let top = self.stack.len() - 1;
while let Some(rule) = self.stack.get_mut(top).next() {
while let Some(rule) = self.stack[top].next() {
// handle conditional group rules
match rule {
&CSSRule::Media(ref rule) => {

170
components/style/values.rs
View file

@ -12,7 +12,7 @@ macro_rules! define_css_keyword_enum {
};
($name: ident: $( $css: expr => $variant: ident ),+) => {
#[allow(non_camel_case_types)]
#[derive(Clone, Eq, PartialEq, FromPrimitive, Copy, Hash, RustcEncodable)]
#[derive(Clone, Eq, PartialEq, Copy, Hash, RustcEncodable, Debug)]
pub enum $name {
$( $variant ),+
}
@ -26,17 +26,9 @@ macro_rules! define_css_keyword_enum {
}
}
impl ::std::fmt::Debug for $name {
#[inline]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
use cssparser::ToCss;
self.fmt_to_css(f)
}
}
impl ::cssparser::ToCss for $name {
fn to_css<W>(&self, dest: &mut W) -> ::text_writer::Result
where W: ::text_writer::TextWriter {
fn to_css<W>(&self, dest: &mut W) -> ::std::fmt::Result
where W: ::std::fmt::Write {
match self {
$( &$name::$variant => dest.write_str($css) ),+
}
@ -51,7 +43,7 @@ macro_rules! define_numbered_css_keyword_enum {
};
($name: ident: $( $css: expr => $variant: ident = $value: expr ),+) => {
#[allow(non_camel_case_types)]
#[derive(Clone, Eq, PartialEq, PartialOrd, Ord, FromPrimitive, Copy, RustcEncodable)]
#[derive(Clone, Eq, PartialEq, PartialOrd, Ord, Copy, RustcEncodable, Debug)]
pub enum $name {
$( $variant = $value ),+
}
@ -65,17 +57,9 @@ macro_rules! define_numbered_css_keyword_enum {
}
}
impl ::std::fmt::Debug for $name {
#[inline]
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
use cssparser::ToCss;
self.fmt_to_css(f)
}
}
impl ::cssparser::ToCss for $name {
fn to_css<W>(&self, dest: &mut W) -> ::text_writer::Result
where W: ::text_writer::TextWriter {
fn to_css<W>(&self, dest: &mut W) -> ::std::fmt::Result
where W: ::std::fmt::Write {
match self {
$( &$name::$variant => dest.write_str($css) ),+
}
@ -85,26 +69,24 @@ macro_rules! define_numbered_css_keyword_enum {
}
pub type CSSFloat = f64;
pub type CSSFloat = f32;
pub mod specified {
use std::ascii::AsciiExt;
use std::cmp;
use std::f64::consts::PI;
use std::f32::consts::PI;
use std::fmt;
use std::fmt::{Formatter, Debug};
use std::num::{NumCast, ToPrimitive};
use std::fmt::Write;
use std::ops::{Add, Mul};
use url::Url;
use cssparser::{self, Token, Parser, ToCss, CssStringWriter};
use geom::size::Size2D;
use parser::ParserContext;
use text_writer::{self, TextWriter};
use util::geometry::Au;
use super::CSSFloat;
#[derive(Clone, PartialEq)]
#[derive(Clone, PartialEq, Debug)]
pub struct CSSColor {
pub parsed: cssparser::Color,
pub authored: Option<String>,
@ -124,12 +106,8 @@ pub mod specified {
}
}
impl fmt::Debug for CSSColor {
#[inline] fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.fmt_to_css(f) }
}
impl ToCss for CSSColor {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match self.authored {
Some(ref s) => dest.write_str(s),
None => self.parsed.to_css(dest),
@ -137,17 +115,14 @@ pub mod specified {
}
}
#[derive(Clone, PartialEq)]
#[derive(Clone, PartialEq, Debug)]
pub struct CSSRGBA {
pub parsed: cssparser::RGBA,
pub authored: Option<String>,
}
impl fmt::Debug for CSSRGBA {
#[inline] fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.fmt_to_css(f) }
}
impl ToCss for CSSRGBA {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match self.authored {
Some(ref s) => dest.write_str(s),
None => self.parsed.to_css(dest),
@ -155,19 +130,15 @@ pub mod specified {
}
}
#[derive(Clone, PartialEq, Copy)]
#[derive(Clone, PartialEq, Copy, Debug)]
pub enum FontRelativeLength {
Em(CSSFloat),
Ex(CSSFloat),
Rem(CSSFloat)
}
impl fmt::Debug for FontRelativeLength {
#[inline] fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.fmt_to_css(f) }
}
impl ToCss for FontRelativeLength {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match self {
&FontRelativeLength::Em(length) => write!(dest, "{}em", length),
&FontRelativeLength::Ex(length) => write!(dest, "{}ex", length),
@ -193,7 +164,7 @@ pub mod specified {
}
}
#[derive(Clone, PartialEq, Copy)]
#[derive(Clone, PartialEq, Copy, Debug)]
pub enum ViewportPercentageLength {
Vw(CSSFloat),
Vh(CSSFloat),
@ -201,12 +172,8 @@ pub mod specified {
Vmax(CSSFloat)
}
impl fmt::Debug for ViewportPercentageLength {
#[inline] fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.fmt_to_css(f) }
}
impl ToCss for ViewportPercentageLength {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match self {
&ViewportPercentageLength::Vw(length) => write!(dest, "{}vw", length),
&ViewportPercentageLength::Vh(length) => write!(dest, "{}vh", length),
@ -220,7 +187,7 @@ pub mod specified {
pub fn to_computed_value(&self, viewport_size: Size2D<Au>) -> Au {
macro_rules! to_unit {
($viewport_dimension:expr) => {
$viewport_dimension.to_f64().unwrap() / 100.0
$viewport_dimension.to_frac32_px() / 100.0
}
}
@ -234,11 +201,11 @@ pub mod specified {
&ViewportPercentageLength::Vmax(length) =>
length * to_unit!(cmp::max(viewport_size.width, viewport_size.height)),
};
NumCast::from(value).unwrap()
Au::from_frac32_px(value)
}
}
#[derive(Clone, PartialEq, Copy)]
#[derive(Clone, PartialEq, Copy, Debug)]
pub struct CharacterWidth(pub i32);
impl CharacterWidth {
@ -253,7 +220,7 @@ pub mod specified {
}
}
#[derive(Clone, PartialEq, Copy)]
#[derive(Clone, PartialEq, Copy, Debug)]
pub enum Length {
Absolute(Au), // application units
FontRelative(FontRelativeLength),
@ -266,14 +233,10 @@ pub mod specified {
ServoCharacterWidth(CharacterWidth),
}
impl fmt::Debug for Length {
#[inline] fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.fmt_to_css(f) }
}
impl ToCss for Length {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match self {
&Length::Absolute(length) => write!(dest, "{}px", length.to_subpx()),
&Length::Absolute(length) => write!(dest, "{}px", length.to_frac32_px()),
&Length::FontRelative(length) => length.to_css(dest),
&Length::ViewportPercentage(length) => length.to_css(dest),
&Length::ServoCharacterWidth(_)
@ -288,7 +251,7 @@ pub mod specified {
#[inline]
fn mul(self, scalar: CSSFloat) -> Length {
match self {
Length::Absolute(Au(v)) => Length::Absolute(Au(((v as f64) * scalar) as i32)),
Length::Absolute(Au(v)) => Length::Absolute(Au(((v as f32) * scalar) as i32)),
Length::FontRelative(v) => Length::FontRelative(v * scalar),
Length::ViewportPercentage(v) => Length::ViewportPercentage(v * scalar),
Length::ServoCharacterWidth(_) => panic!("Can't multiply ServoCharacterWidth!"),
@ -374,18 +337,14 @@ pub mod specified {
}
#[derive(Clone, PartialEq, Copy)]
#[derive(Clone, PartialEq, Copy, Debug)]
pub enum LengthOrPercentage {
Length(Length),
Percentage(CSSFloat), // [0 .. 100%] maps to [0.0 .. 1.0]
}
impl fmt::Debug for LengthOrPercentage {
#[inline] fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.fmt_to_css(f) }
}
impl ToCss for LengthOrPercentage {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match self {
&LengthOrPercentage::Length(length) => length.to_css(dest),
&LengthOrPercentage::Percentage(percentage)
@ -421,19 +380,15 @@ pub mod specified {
}
}
#[derive(Clone, PartialEq, Copy)]
#[derive(Clone, PartialEq, Copy, Debug)]
pub enum LengthOrPercentageOrAuto {
Length(Length),
Percentage(CSSFloat), // [0 .. 100%] maps to [0.0 .. 1.0]
Auto,
}
impl fmt::Debug for LengthOrPercentageOrAuto {
#[inline] fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.fmt_to_css(f) }
}
impl ToCss for LengthOrPercentageOrAuto {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match self {
&LengthOrPercentageOrAuto::Length(length) => length.to_css(dest),
&LengthOrPercentageOrAuto::Percentage(percentage)
@ -472,19 +427,15 @@ pub mod specified {
}
}
#[derive(Clone, PartialEq, Copy)]
#[derive(Clone, PartialEq, Copy, Debug)]
pub enum LengthOrPercentageOrNone {
Length(Length),
Percentage(CSSFloat), // [0 .. 100%] maps to [0.0 .. 1.0]
None,
}
impl fmt::Debug for LengthOrPercentageOrNone {
#[inline] fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.fmt_to_css(f) }
}
impl ToCss for LengthOrPercentageOrNone {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match self {
&LengthOrPercentageOrNone::Length(length) => length.to_css(dest),
&LengthOrPercentageOrNone::Percentage(percentage)
@ -580,7 +531,7 @@ pub mod specified {
fn add(self, other: LengthAndPercentage) -> LengthAndPercentage {
let mut new_lengths = self.lengths.clone();
new_lengths.push_all(other.lengths.as_slice());
new_lengths.push_all(&other.lengths);
LengthAndPercentage {
lengths: new_lengths,
percentage: self.percentage + other.percentage,
@ -650,22 +601,18 @@ pub mod specified {
}
}
#[derive(Clone, PartialEq, PartialOrd, Copy)]
#[derive(Clone, PartialEq, PartialOrd, Copy, Debug)]
pub struct Angle(pub CSSFloat);
impl fmt::Debug for Angle {
#[inline] fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.fmt_to_css(f) }
}
impl ToCss for Angle {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
let Angle(value) = *self;
write!(dest, "{}rad", value)
}
}
impl Angle {
pub fn radians(self) -> f64 {
pub fn radians(self) -> f32 {
let Angle(radians) = self;
radians
}
@ -695,18 +642,14 @@ pub mod specified {
}
/// Specified values for an image according to CSS-IMAGES.
#[derive(Clone, PartialEq)]
#[derive(Clone, PartialEq, Debug)]
pub enum Image {
Url(Url),
LinearGradient(LinearGradient),
}
impl fmt::Debug for Image {
#[inline] fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.fmt_to_css(f) }
}
impl ToCss for Image {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match self {
&Image::Url(ref url) => {
try!(dest.write_str("url(\""));
@ -740,7 +683,7 @@ pub mod specified {
}
/// Specified values for a CSS linear gradient.
#[derive(Clone, PartialEq)]
#[derive(Clone, PartialEq, Debug)]
pub struct LinearGradient {
/// The angle or corner of the gradient.
pub angle_or_corner: AngleOrCorner,
@ -749,42 +692,34 @@ pub mod specified {
pub stops: Vec<ColorStop>,
}
impl fmt::Debug for LinearGradient {
#[inline] fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.fmt_to_css(f) }
}
impl ToCss for LinearGradient {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
try!(dest.write_str("linear-gradient("));
try!(self.angle_or_corner.to_css(dest));
for stop in self.stops.iter() {
try!(dest.write_str(", "));
try!(stop.to_css(dest));
}
try!(dest.write_char(')'));
try!(dest.write_str(")"));
Ok(())
}
}
/// Specified values for an angle or a corner in a linear gradient.
#[derive(Clone, PartialEq, Copy)]
#[derive(Clone, PartialEq, Copy, Debug)]
pub enum AngleOrCorner {
Angle(Angle),
Corner(HorizontalDirection, VerticalDirection),
}
impl fmt::Debug for AngleOrCorner {
#[inline] fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.fmt_to_css(f) }
}
impl ToCss for AngleOrCorner {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match self {
&AngleOrCorner::Angle(angle) => angle.to_css(dest),
&AngleOrCorner::Corner(horizontal, vertical) => {
try!(dest.write_str("to "));
try!(horizontal.to_css(dest));
try!(dest.write_char(' '));
try!(dest.write_str(" "));
try!(vertical.to_css(dest));
Ok(())
}
@ -793,7 +728,7 @@ pub mod specified {
}
/// Specified values for one color stop in a linear gradient.
#[derive(Clone, PartialEq)]
#[derive(Clone, PartialEq, Debug)]
pub struct ColorStop {
/// The color of this stop.
pub color: CSSColor,
@ -803,15 +738,11 @@ pub mod specified {
pub position: Option<LengthOrPercentage>,
}
impl fmt::Debug for ColorStop {
#[inline] fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.fmt_to_css(f) }
}
impl ToCss for ColorStop {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
try!(self.color.to_css(dest));
if let Some(position) = self.position {
try!(dest.write_char(' '));
try!(dest.write_str(" "));
try!(position.to_css(dest));
}
Ok(())
@ -909,7 +840,7 @@ pub mod specified {
impl Time {
/// Returns the time in fractional seconds.
pub fn seconds(self) -> f64 {
pub fn seconds(self) -> f32 {
let Time(seconds) = self;
seconds
}
@ -945,8 +876,8 @@ pub mod specified {
}
impl ToCss for Time {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
dest.write_str(format!("{}ms", self.0).as_slice())
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
write!(dest, "{}ms", self.0)
}
}
}
@ -959,7 +890,6 @@ pub mod computed {
use geom::size::Size2D;
use properties::longhands;
use std::fmt;
use std::marker::MarkerTrait;
use std::ops::{Add, Mul};
use url::Url;
use util::geometry::Au;
@ -995,7 +925,7 @@ pub mod computed {
fn to_computed_value(&self, _context: &Context) -> Self::ComputedValue;
}
pub trait ComputedValueAsSpecified: MarkerTrait {}
pub trait ComputedValueAsSpecified {}
impl<T> ToComputedValue for T where T: ComputedValueAsSpecified + Clone {
type ComputedValue = T;
@ -1184,7 +1114,7 @@ pub mod computed {
fn mul(self, scalar: CSSFloat) -> LengthAndPercentage {
LengthAndPercentage {
length: Au::from_frac_px(self.length.to_subpx() * scalar),
length: Au::from_frac32_px(self.length.to_frac32_px() * scalar),
percentage: self.percentage * scalar,
}
}