2016-03-07 08:11:11 +03:00
|
|
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
|
|
/* 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 http://mozilla.org/MPL/2.0/. */
|
|
|
|
|
|
|
|
#include "mozilla/TimingParams.h"
|
|
|
|
|
2016-03-22 10:20:31 +03:00
|
|
|
#include "mozilla/AnimationUtils.h"
|
|
|
|
#include "mozilla/dom/AnimatableBinding.h"
|
2019-01-08 09:45:18 +03:00
|
|
|
#include "mozilla/dom/Document.h"
|
2016-09-08 23:38:53 +03:00
|
|
|
#include "mozilla/dom/KeyframeAnimationOptionsBinding.h"
|
2016-03-22 10:20:31 +03:00
|
|
|
#include "mozilla/dom/KeyframeEffectBinding.h"
|
2017-12-01 12:35:47 +03:00
|
|
|
#include "mozilla/ServoCSSParser.h"
|
2016-03-11 11:27:34 +03:00
|
|
|
|
2016-03-07 08:11:11 +03:00
|
|
|
namespace mozilla {
|
|
|
|
|
|
|
|
template <class OptionsType>
|
2018-05-07 06:09:54 +03:00
|
|
|
static const dom::EffectTiming& GetTimingProperties(
|
2016-03-07 08:11:11 +03:00
|
|
|
const OptionsType& aOptions);
|
|
|
|
|
|
|
|
template <>
|
2019-02-26 01:05:29 +03:00
|
|
|
/* static */
|
|
|
|
const dom::EffectTiming& GetTimingProperties(
|
2016-03-07 08:11:11 +03:00
|
|
|
const dom::UnrestrictedDoubleOrKeyframeEffectOptions& aOptions) {
|
|
|
|
MOZ_ASSERT(aOptions.IsKeyframeEffectOptions());
|
|
|
|
return aOptions.GetAsKeyframeEffectOptions();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <>
|
2019-02-26 01:05:29 +03:00
|
|
|
/* static */
|
|
|
|
const dom::EffectTiming& GetTimingProperties(
|
2016-03-07 08:11:11 +03:00
|
|
|
const dom::UnrestrictedDoubleOrKeyframeAnimationOptions& aOptions) {
|
|
|
|
MOZ_ASSERT(aOptions.IsKeyframeAnimationOptions());
|
|
|
|
return aOptions.GetAsKeyframeAnimationOptions();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class OptionsType>
|
2019-02-26 01:05:29 +03:00
|
|
|
/* static */
|
|
|
|
TimingParams TimingParams::FromOptionsType(const OptionsType& aOptions,
|
|
|
|
ErrorResult& aRv) {
|
2016-03-09 08:01:45 +03:00
|
|
|
TimingParams result;
|
2018-05-07 06:34:47 +03:00
|
|
|
|
2016-03-07 08:11:11 +03:00
|
|
|
if (aOptions.IsUnrestrictedDouble()) {
|
2016-03-09 08:01:45 +03:00
|
|
|
double durationInMs = aOptions.GetAsUnrestrictedDouble();
|
|
|
|
if (durationInMs >= 0) {
|
|
|
|
result.mDuration.emplace(
|
|
|
|
StickyTimeDuration::FromMilliseconds(durationInMs));
|
|
|
|
} else {
|
2020-02-10 04:35:00 +03:00
|
|
|
nsPrintfCString error("Duration value %g is less than 0", durationInMs);
|
2020-03-07 00:08:02 +03:00
|
|
|
aRv.ThrowTypeError(error);
|
2017-06-22 06:12:42 +03:00
|
|
|
return result;
|
2016-03-09 08:01:45 +03:00
|
|
|
}
|
2018-05-07 06:34:47 +03:00
|
|
|
result.Update();
|
2016-03-07 08:11:11 +03:00
|
|
|
} else {
|
2018-05-07 06:09:54 +03:00
|
|
|
const dom::EffectTiming& timing = GetTimingProperties(aOptions);
|
2020-11-12 23:34:01 +03:00
|
|
|
result = FromEffectTiming(timing, aRv);
|
2016-03-07 08:11:11 +03:00
|
|
|
}
|
2017-06-22 06:12:43 +03:00
|
|
|
|
2016-03-09 08:01:45 +03:00
|
|
|
return result;
|
2016-03-07 08:11:11 +03:00
|
|
|
}
|
|
|
|
|
2019-02-26 01:05:29 +03:00
|
|
|
/* static */
|
|
|
|
TimingParams TimingParams::FromOptionsUnion(
|
2016-03-07 08:11:11 +03:00
|
|
|
const dom::UnrestrictedDoubleOrKeyframeEffectOptions& aOptions,
|
2020-11-12 23:34:01 +03:00
|
|
|
ErrorResult& aRv) {
|
|
|
|
return FromOptionsType(aOptions, aRv);
|
2016-03-07 08:11:11 +03:00
|
|
|
}
|
|
|
|
|
2019-02-26 01:05:29 +03:00
|
|
|
/* static */
|
|
|
|
TimingParams TimingParams::FromOptionsUnion(
|
2016-03-07 08:11:11 +03:00
|
|
|
const dom::UnrestrictedDoubleOrKeyframeAnimationOptions& aOptions,
|
2020-11-12 23:34:01 +03:00
|
|
|
ErrorResult& aRv) {
|
|
|
|
return FromOptionsType(aOptions, aRv);
|
2016-03-07 08:11:11 +03:00
|
|
|
}
|
|
|
|
|
2019-02-26 01:05:29 +03:00
|
|
|
/* static */
|
|
|
|
TimingParams TimingParams::FromEffectTiming(
|
2020-11-12 23:34:01 +03:00
|
|
|
const dom::EffectTiming& aEffectTiming, ErrorResult& aRv) {
|
2018-05-07 06:34:47 +03:00
|
|
|
TimingParams result;
|
|
|
|
|
|
|
|
Maybe<StickyTimeDuration> duration =
|
|
|
|
TimingParams::ParseDuration(aEffectTiming.mDuration, aRv);
|
|
|
|
if (aRv.Failed()) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
TimingParams::ValidateIterationStart(aEffectTiming.mIterationStart, aRv);
|
|
|
|
if (aRv.Failed()) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
TimingParams::ValidateIterations(aEffectTiming.mIterations, aRv);
|
|
|
|
if (aRv.Failed()) {
|
|
|
|
return result;
|
|
|
|
}
|
2022-07-26 17:49:02 +03:00
|
|
|
Maybe<StyleComputedTimingFunction> easing =
|
|
|
|
ParseEasing(aEffectTiming.mEasing, aRv);
|
2018-05-07 06:34:47 +03:00
|
|
|
if (aRv.Failed()) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
result.mDuration = duration;
|
|
|
|
result.mDelay = TimeDuration::FromMilliseconds(aEffectTiming.mDelay);
|
|
|
|
result.mEndDelay = TimeDuration::FromMilliseconds(aEffectTiming.mEndDelay);
|
|
|
|
result.mIterations = aEffectTiming.mIterations;
|
|
|
|
result.mIterationStart = aEffectTiming.mIterationStart;
|
|
|
|
result.mDirection = aEffectTiming.mDirection;
|
|
|
|
result.mFill = aEffectTiming.mFill;
|
2022-07-26 17:49:02 +03:00
|
|
|
result.mFunction = std::move(easing);
|
2018-05-07 06:34:47 +03:00
|
|
|
|
|
|
|
result.Update();
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2019-02-26 01:05:29 +03:00
|
|
|
/* static */
|
|
|
|
TimingParams TimingParams::MergeOptionalEffectTiming(
|
2018-05-07 06:37:11 +03:00
|
|
|
const TimingParams& aSource, const dom::OptionalEffectTiming& aEffectTiming,
|
2020-11-12 23:34:01 +03:00
|
|
|
ErrorResult& aRv) {
|
2018-05-07 06:37:11 +03:00
|
|
|
MOZ_ASSERT(!aRv.Failed(), "Initially return value should be ok");
|
|
|
|
|
|
|
|
TimingParams result = aSource;
|
|
|
|
|
|
|
|
// Check for errors first
|
|
|
|
|
|
|
|
Maybe<StickyTimeDuration> duration;
|
|
|
|
if (aEffectTiming.mDuration.WasPassed()) {
|
|
|
|
duration =
|
|
|
|
TimingParams::ParseDuration(aEffectTiming.mDuration.Value(), aRv);
|
|
|
|
if (aRv.Failed()) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (aEffectTiming.mIterationStart.WasPassed()) {
|
|
|
|
TimingParams::ValidateIterationStart(aEffectTiming.mIterationStart.Value(),
|
|
|
|
aRv);
|
|
|
|
if (aRv.Failed()) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (aEffectTiming.mIterations.WasPassed()) {
|
|
|
|
TimingParams::ValidateIterations(aEffectTiming.mIterations.Value(), aRv);
|
|
|
|
if (aRv.Failed()) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-07-26 17:49:02 +03:00
|
|
|
Maybe<StyleComputedTimingFunction> easing;
|
2018-05-07 06:37:11 +03:00
|
|
|
if (aEffectTiming.mEasing.WasPassed()) {
|
2022-07-26 17:49:02 +03:00
|
|
|
easing = ParseEasing(aEffectTiming.mEasing.Value(), aRv);
|
2018-05-07 06:37:11 +03:00
|
|
|
if (aRv.Failed()) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Assign values
|
|
|
|
|
|
|
|
if (aEffectTiming.mDuration.WasPassed()) {
|
|
|
|
result.mDuration = duration;
|
|
|
|
}
|
|
|
|
if (aEffectTiming.mDelay.WasPassed()) {
|
|
|
|
result.mDelay =
|
|
|
|
TimeDuration::FromMilliseconds(aEffectTiming.mDelay.Value());
|
|
|
|
}
|
|
|
|
if (aEffectTiming.mEndDelay.WasPassed()) {
|
|
|
|
result.mEndDelay =
|
|
|
|
TimeDuration::FromMilliseconds(aEffectTiming.mEndDelay.Value());
|
|
|
|
}
|
|
|
|
if (aEffectTiming.mIterations.WasPassed()) {
|
|
|
|
result.mIterations = aEffectTiming.mIterations.Value();
|
|
|
|
}
|
|
|
|
if (aEffectTiming.mIterationStart.WasPassed()) {
|
|
|
|
result.mIterationStart = aEffectTiming.mIterationStart.Value();
|
|
|
|
}
|
|
|
|
if (aEffectTiming.mDirection.WasPassed()) {
|
|
|
|
result.mDirection = aEffectTiming.mDirection.Value();
|
|
|
|
}
|
|
|
|
if (aEffectTiming.mFill.WasPassed()) {
|
|
|
|
result.mFill = aEffectTiming.mFill.Value();
|
|
|
|
}
|
|
|
|
if (aEffectTiming.mEasing.WasPassed()) {
|
|
|
|
result.mFunction = easing;
|
|
|
|
}
|
|
|
|
|
|
|
|
result.Update();
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2019-02-26 01:05:29 +03:00
|
|
|
/* static */
|
2022-07-26 17:49:02 +03:00
|
|
|
Maybe<StyleComputedTimingFunction> TimingParams::ParseEasing(
|
2020-12-17 17:04:35 +03:00
|
|
|
const nsACString& aEasing, ErrorResult& aRv) {
|
2022-07-26 17:49:02 +03:00
|
|
|
StyleComputedTimingFunction timingFunction;
|
2020-11-12 23:34:01 +03:00
|
|
|
if (!ServoCSSParser::ParseEasing(aEasing, timingFunction)) {
|
2020-12-17 17:04:35 +03:00
|
|
|
aRv.ThrowTypeError<dom::MSG_INVALID_EASING_ERROR>(aEasing);
|
2018-03-25 20:42:10 +03:00
|
|
|
return Nothing();
|
2017-03-21 09:27:46 +03:00
|
|
|
}
|
|
|
|
|
2022-07-26 17:49:02 +03:00
|
|
|
if (timingFunction.IsLinearKeyword()) {
|
2018-03-25 20:42:10 +03:00
|
|
|
return Nothing();
|
|
|
|
}
|
2018-02-01 07:04:04 +03:00
|
|
|
|
2022-07-26 17:49:02 +03:00
|
|
|
return Some(std::move(timingFunction));
|
2016-03-18 10:28:22 +03:00
|
|
|
}
|
|
|
|
|
2016-03-07 08:11:11 +03:00
|
|
|
bool TimingParams::operator==(const TimingParams& aOther) const {
|
2017-06-22 06:12:43 +03:00
|
|
|
// We don't compare mActiveDuration and mEndTime because they are calculated
|
|
|
|
// from other timing parameters.
|
2016-03-09 08:14:20 +03:00
|
|
|
return mDuration == aOther.mDuration && mDelay == aOther.mDelay &&
|
2016-03-07 08:11:11 +03:00
|
|
|
mEndDelay == aOther.mEndDelay && mIterations == aOther.mIterations &&
|
|
|
|
mIterationStart == aOther.mIterationStart &&
|
|
|
|
mDirection == aOther.mDirection && mFill == aOther.mFill &&
|
|
|
|
mFunction == aOther.mFunction;
|
|
|
|
}
|
|
|
|
|
2022-07-07 21:33:42 +03:00
|
|
|
// FIXME: This is a tentative way to normalize the timing which is defined in
|
|
|
|
// [web-animations-2] [1]. I borrow this implementation and some concepts for
|
|
|
|
// the edge cases from Chromium [2] so we can match the behavior with them. The
|
|
|
|
// implementation here ignores the case of percentage of start delay, end delay,
|
|
|
|
// and duration because Gecko doesn't support them. We may have to update the
|
|
|
|
// calculation if the spec issue [3] gets any update.
|
|
|
|
//
|
|
|
|
// [1]
|
|
|
|
// https://drafts.csswg.org/web-animations-2/#time-based-animation-to-a-proportional-animation
|
|
|
|
// [2] https://chromium-review.googlesource.com/c/chromium/src/+/2992387
|
|
|
|
// [3] https://github.com/w3c/csswg-drafts/issues/4862
|
|
|
|
TimingParams TimingParams::Normalize(
|
|
|
|
const TimeDuration& aTimelineDuration) const {
|
|
|
|
MOZ_ASSERT(aTimelineDuration,
|
|
|
|
"the timeline duration of scroll-timeline is always non-zero now");
|
|
|
|
|
|
|
|
TimingParams normalizedTiming(*this);
|
|
|
|
|
|
|
|
// Handle iteration duration value of "auto" first.
|
|
|
|
// FIXME: Bug 1676794: Gecko doesn't support `animation-duration:auto` and we
|
|
|
|
// don't support JS-generated scroll animations, so we don't fall into this
|
|
|
|
// case for now. Need to check this again after we support ScrollTimeline
|
|
|
|
// interface.
|
|
|
|
if (!mDuration) {
|
|
|
|
// If the iteration duration is auto, then:
|
|
|
|
// Set start delay and end delay to 0, as it is not possible to mix time
|
|
|
|
// and proportions.
|
|
|
|
normalizedTiming.mDelay = TimeDuration();
|
|
|
|
normalizedTiming.mEndDelay = TimeDuration();
|
|
|
|
normalizedTiming.Update();
|
|
|
|
return normalizedTiming;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mEndTime.IsZero()) {
|
|
|
|
// mEndTime of zero causes division by zero so we handle it here.
|
|
|
|
//
|
|
|
|
// FIXME: The spec doesn't mention this case, so we might have to update
|
|
|
|
// this based on the spec issue,
|
|
|
|
// https://github.com/w3c/csswg-drafts/issues/7459.
|
|
|
|
normalizedTiming.mDelay = TimeDuration();
|
|
|
|
normalizedTiming.mEndDelay = TimeDuration();
|
|
|
|
normalizedTiming.mDuration = Some(TimeDuration());
|
|
|
|
} else if (mEndTime == TimeDuration::Forever()) {
|
|
|
|
// The iteration count or duration may be infinite; however, start and
|
|
|
|
// end delays are strictly finite. Thus, in the limit when end time
|
|
|
|
// approaches infinity:
|
|
|
|
// start delay / end time = finite / infinite = 0
|
|
|
|
// end delay / end time = finite / infinite = 0
|
|
|
|
// iteration duration / end time = 1 / iteration count
|
|
|
|
// This condition can be reached by switching to a scroll timeline on
|
|
|
|
// an existing infinite duration animation.
|
|
|
|
//
|
|
|
|
// FIXME: The spec doesn't mention this case, so we might have to update
|
|
|
|
// this based on the spec issue,
|
|
|
|
// https://github.com/w3c/csswg-drafts/issues/7459.
|
|
|
|
normalizedTiming.mDelay = TimeDuration();
|
|
|
|
normalizedTiming.mEndDelay = TimeDuration();
|
|
|
|
normalizedTiming.mDuration =
|
|
|
|
Some(aTimelineDuration.MultDouble(1.0 / mIterations));
|
|
|
|
} else {
|
|
|
|
// Convert to percentages then multiply by the timeline duration.
|
|
|
|
const double endTimeInSec = mEndTime.ToSeconds();
|
|
|
|
normalizedTiming.mDelay =
|
|
|
|
aTimelineDuration.MultDouble(mDelay.ToSeconds() / endTimeInSec);
|
|
|
|
normalizedTiming.mEndDelay =
|
|
|
|
aTimelineDuration.MultDouble(mEndDelay.ToSeconds() / endTimeInSec);
|
|
|
|
normalizedTiming.mDuration = Some(StickyTimeDuration(
|
|
|
|
aTimelineDuration.MultDouble(mDuration->ToSeconds() / endTimeInSec)));
|
|
|
|
}
|
Bug 1744850 - Drop ScrollTimeline:sTiming and introduce a normalized timing. r=birtles
`sTiming` is a hack and I believe animation-delay,
animation-iteration-count, animation-direction, and animation-fill-mode
should be meaningful for scroll-linked animations. (I will add the
tentative wpt in Bug 1775327.)
So we need to introduce a normalized timing when resolving the specified
timing.
Also, this patch makes the bug of printing scroll animations detectable.
No behavior is changed and I'd like to remove the magic values and do
normalization in Bug 1775327.
Note: Based on https://github.com/w3c/csswg-drafts/issues/4862 and
web-animations-2, we will introudce CSSNumberish for duration, current
time, and delay. That is, we will accept percentage for
animation-duration, animation-delay. However, Gecko doesn't support
CSSNumberish for those values, so we'd like to normalize these time values
in Bug 1775327. This patch is the 1st step: split the normalized
timing from the specified timing, and use it when resolving the
timing, for progress-based timeline.
Differential Revision: https://phabricator.services.mozilla.com/D149683
2022-06-23 00:19:30 +03:00
|
|
|
|
2022-07-07 21:33:42 +03:00
|
|
|
normalizedTiming.Update();
|
|
|
|
return normalizedTiming;
|
Bug 1744850 - Drop ScrollTimeline:sTiming and introduce a normalized timing. r=birtles
`sTiming` is a hack and I believe animation-delay,
animation-iteration-count, animation-direction, and animation-fill-mode
should be meaningful for scroll-linked animations. (I will add the
tentative wpt in Bug 1775327.)
So we need to introduce a normalized timing when resolving the specified
timing.
Also, this patch makes the bug of printing scroll animations detectable.
No behavior is changed and I'd like to remove the magic values and do
normalization in Bug 1775327.
Note: Based on https://github.com/w3c/csswg-drafts/issues/4862 and
web-animations-2, we will introudce CSSNumberish for duration, current
time, and delay. That is, we will accept percentage for
animation-duration, animation-delay. However, Gecko doesn't support
CSSNumberish for those values, so we'd like to normalize these time values
in Bug 1775327. This patch is the 1st step: split the normalized
timing from the specified timing, and use it when resolving the
timing, for progress-based timeline.
Differential Revision: https://phabricator.services.mozilla.com/D149683
2022-06-23 00:19:30 +03:00
|
|
|
}
|
|
|
|
|
2016-03-07 08:11:11 +03:00
|
|
|
} // namespace mozilla
|