mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-25 19:25:43 +00:00
04b273259e
First, we generate StyleComputedTimingFunction by cbindgen from Rust, and use it in nsTimingFunction, so we could copy it directly without handling the different memory layout. However, we have to rewrite the nsTimingFunction and mozilla::ComputedTimingFunction for this. Second, the rust-bindgen seems cannot generate the correct generic members from complex C++ templates, especially for the nested template struct, (https://github.com/rust-lang-nursery/rust-bindgen/issues/1429) So we have to hide StyleTimingFunction to avoid the compilation errors. Depends on D9312 Differential Revision: https://phabricator.services.mozilla.com/D9313 --HG-- extra : moz-landing-system : lando
241 lines
6.7 KiB
C++
241 lines
6.7 KiB
C++
/* -*- 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"
|
|
|
|
#include "mozilla/AnimationUtils.h"
|
|
#include "mozilla/dom/AnimatableBinding.h"
|
|
#include "mozilla/dom/KeyframeAnimationOptionsBinding.h"
|
|
#include "mozilla/dom/KeyframeEffectBinding.h"
|
|
#include "mozilla/ServoCSSParser.h"
|
|
#include "nsIDocument.h"
|
|
|
|
namespace mozilla {
|
|
|
|
template <class OptionsType>
|
|
static const dom::EffectTiming&
|
|
GetTimingProperties(const OptionsType& aOptions);
|
|
|
|
template <>
|
|
/* static */ const dom::EffectTiming&
|
|
GetTimingProperties(
|
|
const dom::UnrestrictedDoubleOrKeyframeEffectOptions& aOptions)
|
|
{
|
|
MOZ_ASSERT(aOptions.IsKeyframeEffectOptions());
|
|
return aOptions.GetAsKeyframeEffectOptions();
|
|
}
|
|
|
|
template <>
|
|
/* static */ const dom::EffectTiming&
|
|
GetTimingProperties(
|
|
const dom::UnrestrictedDoubleOrKeyframeAnimationOptions& aOptions)
|
|
{
|
|
MOZ_ASSERT(aOptions.IsKeyframeAnimationOptions());
|
|
return aOptions.GetAsKeyframeAnimationOptions();
|
|
}
|
|
|
|
template <class OptionsType>
|
|
/* static */ TimingParams
|
|
TimingParams::FromOptionsType(const OptionsType& aOptions,
|
|
nsIDocument* aDocument,
|
|
ErrorResult& aRv)
|
|
{
|
|
TimingParams result;
|
|
|
|
if (aOptions.IsUnrestrictedDouble()) {
|
|
double durationInMs = aOptions.GetAsUnrestrictedDouble();
|
|
if (durationInMs >= 0) {
|
|
result.mDuration.emplace(
|
|
StickyTimeDuration::FromMilliseconds(durationInMs));
|
|
} else {
|
|
aRv.Throw(NS_ERROR_DOM_TYPE_ERR);
|
|
return result;
|
|
}
|
|
result.Update();
|
|
} else {
|
|
const dom::EffectTiming& timing = GetTimingProperties(aOptions);
|
|
result = FromEffectTiming(timing, aDocument, aRv);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/* static */ TimingParams
|
|
TimingParams::FromOptionsUnion(
|
|
const dom::UnrestrictedDoubleOrKeyframeEffectOptions& aOptions,
|
|
nsIDocument* aDocument,
|
|
ErrorResult& aRv)
|
|
{
|
|
return FromOptionsType(aOptions, aDocument, aRv);
|
|
}
|
|
|
|
/* static */ TimingParams
|
|
TimingParams::FromOptionsUnion(
|
|
const dom::UnrestrictedDoubleOrKeyframeAnimationOptions& aOptions,
|
|
nsIDocument* aDocument,
|
|
ErrorResult& aRv)
|
|
{
|
|
return FromOptionsType(aOptions, aDocument, aRv);
|
|
}
|
|
|
|
/* static */ TimingParams
|
|
TimingParams::FromEffectTiming(const dom::EffectTiming& aEffectTiming,
|
|
nsIDocument* aDocument,
|
|
ErrorResult& aRv)
|
|
{
|
|
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;
|
|
}
|
|
Maybe<ComputedTimingFunction> easing =
|
|
TimingParams::ParseEasing(aEffectTiming.mEasing, aDocument, aRv);
|
|
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;
|
|
result.mFunction = easing;
|
|
|
|
result.Update();
|
|
|
|
return result;
|
|
}
|
|
|
|
/* static */ TimingParams
|
|
TimingParams::MergeOptionalEffectTiming(
|
|
const TimingParams& aSource,
|
|
const dom::OptionalEffectTiming& aEffectTiming,
|
|
nsIDocument* aDocument,
|
|
ErrorResult& aRv)
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
|
|
Maybe<ComputedTimingFunction> easing;
|
|
if (aEffectTiming.mEasing.WasPassed()) {
|
|
easing =
|
|
TimingParams::ParseEasing(aEffectTiming.mEasing.Value(), aDocument, aRv);
|
|
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;
|
|
}
|
|
|
|
/* static */ Maybe<ComputedTimingFunction>
|
|
TimingParams::ParseEasing(const nsAString& aEasing,
|
|
nsIDocument* aDocument,
|
|
ErrorResult& aRv)
|
|
{
|
|
MOZ_ASSERT(aDocument);
|
|
|
|
nsTimingFunction timingFunction;
|
|
RefPtr<URLExtraData> url = ServoCSSParser::GetURLExtraData(aDocument);
|
|
if (!ServoCSSParser::ParseEasing(aEasing, url, timingFunction)) {
|
|
aRv.ThrowTypeError<dom::MSG_INVALID_EASING_ERROR>(aEasing);
|
|
return Nothing();
|
|
}
|
|
|
|
if (timingFunction.IsLinear()) {
|
|
return Nothing();
|
|
}
|
|
|
|
return Some(ComputedTimingFunction(timingFunction));
|
|
}
|
|
|
|
bool
|
|
TimingParams::operator==(const TimingParams& aOther) const
|
|
{
|
|
// We don't compare mActiveDuration and mEndTime because they are calculated
|
|
// from other timing parameters.
|
|
return mDuration == aOther.mDuration &&
|
|
mDelay == aOther.mDelay &&
|
|
mEndDelay == aOther.mEndDelay &&
|
|
mIterations == aOther.mIterations &&
|
|
mIterationStart == aOther.mIterationStart &&
|
|
mDirection == aOther.mDirection &&
|
|
mFill == aOther.mFill &&
|
|
mFunction == aOther.mFunction;
|
|
}
|
|
|
|
} // namespace mozilla
|