f49da1c698
The main issue here is that we transition the zoomed value, which is generally wrong because the animated value gets injected back into the cascade (and thus zoomed again). We happen to cancel the transition in [1], which is kinda nice because otherwise we would've just transitioned to a completely wrong value (and maybe indefinitely, since values would keep getting bigger and bigger...). We need to do something similar to to_resolved_value, and unzoom lengths in to_animated_value, that is, interpolate "unzoomed" values. The extra test to test_transitions_per_property caught some existing issues with calc() and zoom which are fixed too for the test to pass. Same for the ToResolvedValue for Au, that is needed for properties like column-rule-width to return the correct resolved values. Main thing I left unfixed is bug 1909280, but that deserves a more subtle test and a bit more thought because only matrix components need to be zoomed. While at it, I simplified the animation setup a little bit, removing the special animation_value_type="ComputedValue", which means that we need to add a few ToAnimatedValue calls. Now the only values are "none", "discrete", and "normal", and given it's not a value type anymore I called it just "animation_type". This got a bit bigger than I would've liked, but also it fixes more bugs that what I was originally expecting, so... :) [1]: https://searchfox.org/mozilla-central/rev/5756c5a3dea4f2896cdb3c8bb15d0ced5e2bf690/layout/style/nsTransitionManager.cpp#168-171 Differential Revision: https://phabricator.services.mozilla.com/D217308
72 lines
2.0 KiB
Rust
72 lines
2.0 KiB
Rust
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
|
|
|
|
//! Computed types for CSS values that are related to motion path.
|
|
|
|
use crate::values::computed::basic_shape::BasicShape;
|
|
use crate::values::computed::url::ComputedUrl;
|
|
use crate::values::computed::{Angle, LengthPercentage, Position};
|
|
use crate::values::generics::motion::{
|
|
GenericOffsetPath, GenericOffsetPathFunction, GenericOffsetPosition, GenericRayFunction,
|
|
};
|
|
use crate::Zero;
|
|
|
|
/// The computed value of ray() function.
|
|
pub type RayFunction = GenericRayFunction<Angle, Position>;
|
|
|
|
/// The computed value of <offset-path>.
|
|
pub type OffsetPathFunction = GenericOffsetPathFunction<BasicShape, RayFunction, ComputedUrl>;
|
|
|
|
/// The computed value of `offset-path`.
|
|
pub type OffsetPath = GenericOffsetPath<OffsetPathFunction>;
|
|
|
|
/// The computed value of `offset-position`.
|
|
pub type OffsetPosition = GenericOffsetPosition<LengthPercentage, LengthPercentage>;
|
|
|
|
#[inline]
|
|
fn is_auto_zero_angle(auto: &bool, angle: &Angle) -> bool {
|
|
*auto && angle.is_zero()
|
|
}
|
|
|
|
/// A computed offset-rotate.
|
|
#[derive(
|
|
Animate,
|
|
Clone,
|
|
ComputeSquaredDistance,
|
|
Copy,
|
|
Debug,
|
|
Deserialize,
|
|
MallocSizeOf,
|
|
PartialEq,
|
|
Serialize,
|
|
ToAnimatedValue,
|
|
ToAnimatedZero,
|
|
ToCss,
|
|
ToResolvedValue,
|
|
)]
|
|
#[repr(C)]
|
|
pub struct OffsetRotate {
|
|
/// If auto is false, this is a fixed angle which indicates a
|
|
/// constant clockwise rotation transformation applied to it by this
|
|
/// specified rotation angle. Otherwise, the angle will be added to
|
|
/// the angle of the direction in layout.
|
|
#[animation(constant)]
|
|
#[css(represents_keyword)]
|
|
pub auto: bool,
|
|
/// The angle value.
|
|
#[css(contextual_skip_if = "is_auto_zero_angle")]
|
|
pub angle: Angle,
|
|
}
|
|
|
|
impl OffsetRotate {
|
|
/// Returns "auto 0deg".
|
|
#[inline]
|
|
pub fn auto() -> Self {
|
|
OffsetRotate {
|
|
auto: true,
|
|
angle: Zero::zero(),
|
|
}
|
|
}
|
|
}
|