#pragma once
#include "AnimationEffect.h"
#include "ComputedEffectTiming.h"
#include "ExceptionOr.h"
#include "FillMode.h"
#include "KeyframeEffectOptions.h"
#include "OptionalEffectTiming.h"
#include "PlaybackDirection.h"
#include "TimingFunction.h"
#include "WebAnimation.h"
#include "WebAnimationUtilities.h"
#include <wtf/Forward.h>
#include <wtf/Ref.h>
#include <wtf/RefCounted.h>
#include <wtf/RefPtr.h>
#include <wtf/Seconds.h>
#include <wtf/Variant.h>
#include <wtf/WeakPtr.h>
namespace WebCore {
class AnimationEffect : public RefCounted<AnimationEffect> {
public:
virtual ~AnimationEffect();
virtual bool isKeyframeEffect() const { return false; }
EffectTiming getTiming();
ComputedEffectTiming getComputedTiming();
ExceptionOr<void> updateTiming(Optional<OptionalEffectTiming>);
virtual void apply(RenderStyle&) = 0;
virtual void invalidate() = 0;
virtual void animationDidSeek() = 0;
virtual void animationSuspensionStateDidChange(bool) = 0;
WebAnimation* animation() const { return m_animation.get(); }
void setAnimation(WebAnimation* animation) { m_animation = makeWeakPtr(animation); }
Seconds delay() const { return m_delay; }
void setDelay(const Seconds&);
Seconds endDelay() const { return m_endDelay; }
void setEndDelay(const Seconds&);
FillMode fill() const { return m_fill; }
void setFill(FillMode);
double iterationStart() const { return m_iterationStart; }
ExceptionOr<void> setIterationStart(double);
double iterations() const { return m_iterations; }
ExceptionOr<void> setIterations(double);
Seconds iterationDuration() const { return m_iterationDuration; }
void setIterationDuration(const Seconds&);
PlaybackDirection direction() const { return m_direction; }
void setDirection(PlaybackDirection);
TimingFunction* timingFunction() const { return m_timingFunction.get(); }
void setTimingFunction(const RefPtr<TimingFunction>&);
Optional<Seconds> localTime() const;
Optional<Seconds> activeTime() const;
Seconds endTime() const;
Optional<double> simpleIterationProgress() const;
Optional<double> iterationProgress() const;
Optional<double> currentIteration() const;
Seconds activeDuration() const;
enum class Phase { Before, Active, After, Idle };
Phase phase() const;
protected:
explicit AnimationEffect();
private:
enum class ComputedDirection { Forwards, Reverse };
Optional<double> overallProgress() const;
AnimationEffect::ComputedDirection currentDirection() const;
Optional<double> directedProgress() const;
Optional<double> transformedProgress() const;
Seconds m_delay { 0_s };
Seconds m_endDelay { 0_s };
FillMode m_fill { FillMode::Auto };
double m_iterationStart { 0 };
double m_iterations { 1 };
Seconds m_iterationDuration { 0_s };
PlaybackDirection m_direction { PlaybackDirection::Normal };
RefPtr<TimingFunction> m_timingFunction;
WeakPtr<WebAnimation> m_animation;
};
}
#define SPECIALIZE_TYPE_TRAITS_ANIMATION_EFFECT(ToValueTypeName, predicate) \
SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::ToValueTypeName) \
static bool isType(const WebCore::AnimationEffect& value) { return value.predicate; } \
SPECIALIZE_TYPE_TRAITS_END()