mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
a8a325e307
Now that there is a public accessor for mStartTime, we can make it a protected member of AnimationPlayer. The only time mStartTime is ever set is when playing the animation so we can replace external modifications to mStartTime with calls to Play(). This simplifies implementing deferred starting of animations in bug 927349 by isolating the deferred playback logic to AnimationPlayer. Note that even when we call PauseFromStyle immediately afterwards we still need to call PlayFromStyle (or Play) first in order to resolve the time at which the player should be paused. A newly created player doesn't have a current time so if we were simply to call pause it wouldn't pause at the start of the animation as we might expect. The call to Play(FromStyle) will cause the current time to become zero and then we pause at that time.
766 lines
30 KiB
C++
766 lines
30 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set shiftwidth=2 tabstop=8 autoindent cindent expandtab: */
|
|
/* 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/. */
|
|
|
|
/* Code to start and animate CSS transitions. */
|
|
|
|
#include "nsTransitionManager.h"
|
|
#include "nsAnimationManager.h"
|
|
#include "nsIContent.h"
|
|
#include "nsStyleContext.h"
|
|
#include "nsCSSProps.h"
|
|
#include "mozilla/MemoryReporting.h"
|
|
#include "mozilla/TimeStamp.h"
|
|
#include "nsRefreshDriver.h"
|
|
#include "nsRuleProcessorData.h"
|
|
#include "nsRuleWalker.h"
|
|
#include "nsCSSPropertySet.h"
|
|
#include "mozilla/EventDispatcher.h"
|
|
#include "mozilla/ContentEvents.h"
|
|
#include "mozilla/StyleAnimationValue.h"
|
|
#include "mozilla/dom/Element.h"
|
|
#include "nsIFrame.h"
|
|
#include "Layers.h"
|
|
#include "FrameLayerBuilder.h"
|
|
#include "nsDisplayList.h"
|
|
#include "nsStyleChangeList.h"
|
|
#include "nsStyleSet.h"
|
|
#include "RestyleManager.h"
|
|
|
|
using mozilla::TimeStamp;
|
|
using mozilla::TimeDuration;
|
|
using mozilla::dom::AnimationPlayer;
|
|
using mozilla::dom::Animation;
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::layers;
|
|
using namespace mozilla::css;
|
|
|
|
double
|
|
ElementPropertyTransition::CurrentValuePortion() const
|
|
{
|
|
// It would be easy enough to handle finished transitions by using a time
|
|
// fraction of 1 but currently we should not be called for finished
|
|
// transitions.
|
|
MOZ_ASSERT(!IsFinishedTransition(),
|
|
"Getting the value portion of a finished transition");
|
|
MOZ_ASSERT(!GetLocalTime().IsNull(),
|
|
"Getting the value portion of an animation that's not being "
|
|
"sampled");
|
|
|
|
// Transitions use a fill mode of 'backwards' so GetComputedTiming will
|
|
// never return a null time fraction due to being *before* the animation
|
|
// interval. However, it might be possible that we're behind on flushing
|
|
// causing us to get called *after* the animation interval. So, just in
|
|
// case, we override the fill mode to 'both' to ensure the time fraction
|
|
// is never null.
|
|
AnimationTiming timingToUse = mTiming;
|
|
timingToUse.mFillMode = NS_STYLE_ANIMATION_FILL_MODE_BOTH;
|
|
ComputedTiming computedTiming = GetComputedTiming(&timingToUse);
|
|
|
|
MOZ_ASSERT(computedTiming.mTimeFraction != ComputedTiming::kNullTimeFraction,
|
|
"Got a null time fraction for a fill mode of 'both'");
|
|
MOZ_ASSERT(mProperties.Length() == 1,
|
|
"Should have one animation property for a transition");
|
|
MOZ_ASSERT(mProperties[0].mSegments.Length() == 1,
|
|
"Animation property should have one segment for a transition");
|
|
return mProperties[0].mSegments[0].mTimingFunction
|
|
.GetValue(computedTiming.mTimeFraction);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* CSSTransitionPlayer *
|
|
*****************************************************************************/
|
|
|
|
mozilla::dom::AnimationPlayState
|
|
CSSTransitionPlayer::PlayStateFromJS() const
|
|
{
|
|
FlushStyle();
|
|
return AnimationPlayer::PlayStateFromJS();
|
|
}
|
|
|
|
void
|
|
CSSTransitionPlayer::PlayFromJS()
|
|
{
|
|
FlushStyle();
|
|
AnimationPlayer::PlayFromJS();
|
|
}
|
|
|
|
CommonAnimationManager*
|
|
CSSTransitionPlayer::GetAnimationManager() const
|
|
{
|
|
nsPresContext* context = GetPresContext();
|
|
if (!context) {
|
|
return nullptr;
|
|
}
|
|
|
|
return context->TransitionManager();
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* nsTransitionManager *
|
|
*****************************************************************************/
|
|
|
|
already_AddRefed<nsIStyleRule>
|
|
nsTransitionManager::StyleContextChanged(dom::Element *aElement,
|
|
nsStyleContext *aOldStyleContext,
|
|
nsStyleContext *aNewStyleContext)
|
|
{
|
|
NS_PRECONDITION(aOldStyleContext->GetPseudo() ==
|
|
aNewStyleContext->GetPseudo(),
|
|
"pseudo type mismatch");
|
|
|
|
if (mInAnimationOnlyStyleUpdate) {
|
|
// If we're doing an animation-only style update, return, since the
|
|
// purpose of an animation-only style update is to update only the
|
|
// animation styles so that we don't consider style changes
|
|
// resulting from changes in the animation time for starting a
|
|
// transition.
|
|
return nullptr;
|
|
}
|
|
|
|
if (!mPresContext->IsDynamic()) {
|
|
// For print or print preview, ignore transitions.
|
|
return nullptr;
|
|
}
|
|
|
|
if (aOldStyleContext->HasPseudoElementData() !=
|
|
aNewStyleContext->HasPseudoElementData()) {
|
|
// If the old style context and new style context differ in terms of
|
|
// whether they're inside ::first-letter, ::first-line, or similar,
|
|
// bail. We can't hit this codepath for normal style changes
|
|
// involving moving frames around the boundaries of these
|
|
// pseudo-elements since we don't call StyleContextChanged from
|
|
// ReparentStyleContext. However, we can hit this codepath during
|
|
// the handling of transitions that start across reframes.
|
|
//
|
|
// While there isn't an easy *perfect* way to handle this case, err
|
|
// on the side of missing some transitions that we ought to have
|
|
// rather than having bogus transitions that we shouldn't.
|
|
//
|
|
// We could consider changing this handling, although it's worth
|
|
// thinking about whether the code below could do anything weird in
|
|
// this case.
|
|
return nullptr;
|
|
}
|
|
|
|
// NOTE: Things in this function (and ConsiderStartingTransition)
|
|
// should never call PeekStyleData because we don't preserve gotten
|
|
// structs across reframes.
|
|
|
|
// Return sooner (before the startedAny check below) for the most
|
|
// common case: no transitions specified or running.
|
|
const nsStyleDisplay *disp = aNewStyleContext->StyleDisplay();
|
|
nsCSSPseudoElements::Type pseudoType = aNewStyleContext->GetPseudoType();
|
|
if (pseudoType != nsCSSPseudoElements::ePseudo_NotPseudoElement) {
|
|
if (pseudoType != nsCSSPseudoElements::ePseudo_before &&
|
|
pseudoType != nsCSSPseudoElements::ePseudo_after) {
|
|
return nullptr;
|
|
}
|
|
|
|
NS_ASSERTION((pseudoType == nsCSSPseudoElements::ePseudo_before &&
|
|
aElement->Tag() == nsGkAtoms::mozgeneratedcontentbefore) ||
|
|
(pseudoType == nsCSSPseudoElements::ePseudo_after &&
|
|
aElement->Tag() == nsGkAtoms::mozgeneratedcontentafter),
|
|
"Unexpected aElement coming through");
|
|
|
|
// Else the element we want to use from now on is the element the
|
|
// :before or :after is attached to.
|
|
aElement = aElement->GetParent()->AsElement();
|
|
}
|
|
|
|
AnimationPlayerCollection* collection =
|
|
GetAnimationPlayers(aElement, pseudoType, false);
|
|
if (!collection &&
|
|
disp->mTransitionPropertyCount == 1 &&
|
|
disp->mTransitions[0].GetDelay() == 0.0f &&
|
|
disp->mTransitions[0].GetDuration() == 0.0f) {
|
|
return nullptr;
|
|
}
|
|
|
|
|
|
// FIXME (bug 960465): This test should go away.
|
|
if (aNewStyleContext->PresContext()->RestyleManager()->
|
|
IsProcessingAnimationStyleChange()) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (aNewStyleContext->GetParent() &&
|
|
aNewStyleContext->GetParent()->HasPseudoElementData()) {
|
|
// Ignore transitions on things that inherit properties from
|
|
// pseudo-elements.
|
|
// FIXME (Bug 522599): Add tests for this.
|
|
return nullptr;
|
|
}
|
|
|
|
NS_WARN_IF_FALSE(!nsLayoutUtils::AreAsyncAnimationsEnabled() ||
|
|
mPresContext->RestyleManager()->
|
|
ThrottledAnimationStyleIsUpToDate(),
|
|
"throttled animations not up to date");
|
|
|
|
// Per http://lists.w3.org/Archives/Public/www-style/2009Aug/0109.html
|
|
// I'll consider only the transitions from the number of items in
|
|
// 'transition-property' on down, and later ones will override earlier
|
|
// ones (tracked using |whichStarted|).
|
|
bool startedAny = false;
|
|
nsCSSPropertySet whichStarted;
|
|
for (uint32_t i = disp->mTransitionPropertyCount; i-- != 0; ) {
|
|
const StyleTransition& t = disp->mTransitions[i];
|
|
// Check delay and duration first, since they default to zero, and
|
|
// when they're both zero, we can ignore the transition.
|
|
if (t.GetDelay() != 0.0f || t.GetDuration() != 0.0f) {
|
|
// We might have something to transition. See if any of the
|
|
// properties in question changed and are animatable.
|
|
// FIXME: Would be good to find a way to share code between this
|
|
// interpretation of transition-property and the one below.
|
|
nsCSSProperty property = t.GetProperty();
|
|
if (property == eCSSPropertyExtra_no_properties ||
|
|
property == eCSSPropertyExtra_variable ||
|
|
property == eCSSProperty_UNKNOWN) {
|
|
// Nothing to do, but need to exclude this from cases below.
|
|
} else if (property == eCSSPropertyExtra_all_properties) {
|
|
for (nsCSSProperty p = nsCSSProperty(0);
|
|
p < eCSSProperty_COUNT_no_shorthands;
|
|
p = nsCSSProperty(p + 1)) {
|
|
ConsiderStartingTransition(p, t, aElement, collection,
|
|
aOldStyleContext, aNewStyleContext,
|
|
&startedAny, &whichStarted);
|
|
}
|
|
} else if (nsCSSProps::IsShorthand(property)) {
|
|
CSSPROPS_FOR_SHORTHAND_SUBPROPERTIES(subprop, property) {
|
|
ConsiderStartingTransition(*subprop, t, aElement, collection,
|
|
aOldStyleContext, aNewStyleContext,
|
|
&startedAny, &whichStarted);
|
|
}
|
|
} else {
|
|
ConsiderStartingTransition(property, t, aElement, collection,
|
|
aOldStyleContext, aNewStyleContext,
|
|
&startedAny, &whichStarted);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Stop any transitions for properties that are no longer in
|
|
// 'transition-property'.
|
|
// Also stop any transitions for properties that just changed (and are
|
|
// still in the set of properties to transition), but we didn't just
|
|
// start the transition because delay and duration are both zero.
|
|
if (collection) {
|
|
bool checkProperties =
|
|
disp->mTransitions[0].GetProperty() != eCSSPropertyExtra_all_properties;
|
|
nsCSSPropertySet allTransitionProperties;
|
|
if (checkProperties) {
|
|
for (uint32_t i = disp->mTransitionPropertyCount; i-- != 0; ) {
|
|
const StyleTransition& t = disp->mTransitions[i];
|
|
// FIXME: Would be good to find a way to share code between this
|
|
// interpretation of transition-property and the one above.
|
|
nsCSSProperty property = t.GetProperty();
|
|
if (property == eCSSPropertyExtra_no_properties ||
|
|
property == eCSSPropertyExtra_variable ||
|
|
property == eCSSProperty_UNKNOWN) {
|
|
// Nothing to do, but need to exclude this from cases below.
|
|
} else if (property == eCSSPropertyExtra_all_properties) {
|
|
for (nsCSSProperty p = nsCSSProperty(0);
|
|
p < eCSSProperty_COUNT_no_shorthands;
|
|
p = nsCSSProperty(p + 1)) {
|
|
allTransitionProperties.AddProperty(p);
|
|
}
|
|
} else if (nsCSSProps::IsShorthand(property)) {
|
|
CSSPROPS_FOR_SHORTHAND_SUBPROPERTIES(subprop, property) {
|
|
allTransitionProperties.AddProperty(*subprop);
|
|
}
|
|
} else {
|
|
allTransitionProperties.AddProperty(property);
|
|
}
|
|
}
|
|
}
|
|
|
|
AnimationPlayerPtrArray& players = collection->mPlayers;
|
|
size_t i = players.Length();
|
|
NS_ABORT_IF_FALSE(i != 0, "empty transitions list?");
|
|
StyleAnimationValue currentValue;
|
|
do {
|
|
--i;
|
|
AnimationPlayer* player = players[i];
|
|
dom::Animation* anim = player->GetSource();
|
|
MOZ_ASSERT(anim && anim->Properties().Length() == 1,
|
|
"Should have one animation property for a transition");
|
|
MOZ_ASSERT(anim && anim->Properties()[0].mSegments.Length() == 1,
|
|
"Animation property should have one segment for a transition");
|
|
const AnimationProperty& prop = anim->Properties()[0];
|
|
const AnimationPropertySegment& segment = prop.mSegments[0];
|
|
// properties no longer in 'transition-property'
|
|
if ((checkProperties &&
|
|
!allTransitionProperties.HasProperty(prop.mProperty)) ||
|
|
// properties whose computed values changed but delay and
|
|
// duration are both zero
|
|
!ExtractComputedValueForTransition(prop.mProperty, aNewStyleContext,
|
|
currentValue) ||
|
|
currentValue != segment.mToValue) {
|
|
// stop the transition
|
|
players.RemoveElementAt(i);
|
|
collection->UpdateAnimationGeneration(mPresContext);
|
|
}
|
|
} while (i != 0);
|
|
|
|
if (players.IsEmpty()) {
|
|
collection->Destroy();
|
|
collection = nullptr;
|
|
}
|
|
}
|
|
|
|
if (!startedAny) {
|
|
return nullptr;
|
|
}
|
|
|
|
NS_ABORT_IF_FALSE(collection, "must have element transitions if we started "
|
|
"any transitions");
|
|
|
|
// In the CSS working group discussion (2009 Jul 15 telecon,
|
|
// http://www.w3.org/mid/4A5E1470.4030904@inkedblade.net ) of
|
|
// http://lists.w3.org/Archives/Public/www-style/2009Jun/0121.html ,
|
|
// the working group decided that a transition property on an
|
|
// element should not cause any transitions if the property change
|
|
// is itself inheriting a value that is transitioning on an
|
|
// ancestor. So, to get the correct behavior, we continue the
|
|
// restyle that caused this transition using a "covering" rule that
|
|
// covers up any changes on which we started transitions, so that
|
|
// descendants don't start their own transitions. (In the case of
|
|
// negative transition delay, this covering rule produces different
|
|
// results than applying the transition rule immediately would).
|
|
// Our caller is responsible for restyling again using this covering
|
|
// rule.
|
|
|
|
nsRefPtr<css::AnimValuesStyleRule> coverRule = new css::AnimValuesStyleRule;
|
|
|
|
AnimationPlayerPtrArray& players = collection->mPlayers;
|
|
for (size_t i = 0, i_end = players.Length(); i < i_end; ++i) {
|
|
dom::Animation* anim = players[i]->GetSource();
|
|
MOZ_ASSERT(anim && anim->Properties().Length() == 1,
|
|
"Should have one animation property for a transition");
|
|
MOZ_ASSERT(anim && anim->Properties()[0].mSegments.Length() == 1,
|
|
"Animation property should have one segment for a transition");
|
|
AnimationProperty& prop = anim->Properties()[0];
|
|
AnimationPropertySegment& segment = prop.mSegments[0];
|
|
if (whichStarted.HasProperty(prop.mProperty)) {
|
|
coverRule->AddValue(prop.mProperty, segment.mFromValue);
|
|
}
|
|
}
|
|
|
|
// Set the style rule refresh time to null so that EnsureStyleRuleFor
|
|
// creates a new style rule.
|
|
collection->mStyleRuleRefreshTime = TimeStamp();
|
|
|
|
return coverRule.forget();
|
|
}
|
|
|
|
void
|
|
nsTransitionManager::ConsiderStartingTransition(
|
|
nsCSSProperty aProperty,
|
|
const StyleTransition& aTransition,
|
|
dom::Element* aElement,
|
|
AnimationPlayerCollection*& aElementTransitions,
|
|
nsStyleContext* aOldStyleContext,
|
|
nsStyleContext* aNewStyleContext,
|
|
bool* aStartedAny,
|
|
nsCSSPropertySet* aWhichStarted)
|
|
{
|
|
// IsShorthand itself will assert if aProperty is not a property.
|
|
NS_ABORT_IF_FALSE(!nsCSSProps::IsShorthand(aProperty),
|
|
"property out of range");
|
|
NS_ASSERTION(!aElementTransitions ||
|
|
aElementTransitions->mElement == aElement, "Element mismatch");
|
|
|
|
if (aWhichStarted->HasProperty(aProperty)) {
|
|
// A later item in transition-property already started a
|
|
// transition for this property, so we ignore this one.
|
|
// See comment above and
|
|
// http://lists.w3.org/Archives/Public/www-style/2009Aug/0109.html .
|
|
return;
|
|
}
|
|
|
|
if (nsCSSProps::kAnimTypeTable[aProperty] == eStyleAnimType_None) {
|
|
return;
|
|
}
|
|
|
|
dom::AnimationTimeline* timeline = aElement->OwnerDoc()->Timeline();
|
|
|
|
StyleAnimationValue startValue, endValue, dummyValue;
|
|
bool haveValues =
|
|
ExtractComputedValueForTransition(aProperty, aOldStyleContext,
|
|
startValue) &&
|
|
ExtractComputedValueForTransition(aProperty, aNewStyleContext,
|
|
endValue);
|
|
|
|
bool haveChange = startValue != endValue;
|
|
|
|
bool shouldAnimate =
|
|
haveValues &&
|
|
haveChange &&
|
|
// Check that we can interpolate between these values
|
|
// (If this is ever a performance problem, we could add a
|
|
// CanInterpolate method, but it seems fine for now.)
|
|
StyleAnimationValue::Interpolate(aProperty, startValue, endValue,
|
|
0.5, dummyValue);
|
|
|
|
bool haveCurrentTransition = false;
|
|
size_t currentIndex = nsTArray<ElementPropertyTransition>::NoIndex;
|
|
const ElementPropertyTransition *oldPT = nullptr;
|
|
if (aElementTransitions) {
|
|
AnimationPlayerPtrArray& players = aElementTransitions->mPlayers;
|
|
for (size_t i = 0, i_end = players.Length(); i < i_end; ++i) {
|
|
MOZ_ASSERT(players[i]->GetSource() &&
|
|
players[i]->GetSource()->Properties().Length() == 1,
|
|
"Should have one animation property for a transition");
|
|
if (players[i]->GetSource()->Properties()[0].mProperty == aProperty) {
|
|
haveCurrentTransition = true;
|
|
currentIndex = i;
|
|
oldPT = players[currentIndex]->GetSource()->AsTransition();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If we got a style change that changed the value to the endpoint
|
|
// of the currently running transition, we don't want to interrupt
|
|
// its timing function.
|
|
// This needs to be before the !shouldAnimate && haveCurrentTransition
|
|
// case below because we might be close enough to the end of the
|
|
// transition that the current value rounds to the final value. In
|
|
// this case, we'll end up with shouldAnimate as false (because
|
|
// there's no value change), but we need to return early here rather
|
|
// than cancel the running transition because shouldAnimate is false!
|
|
MOZ_ASSERT(!oldPT || oldPT->Properties()[0].mSegments.Length() == 1,
|
|
"Should have one animation property segment for a transition");
|
|
if (haveCurrentTransition && haveValues &&
|
|
oldPT->Properties()[0].mSegments[0].mToValue == endValue) {
|
|
// GetAnimationRule already called RestyleForAnimation.
|
|
return;
|
|
}
|
|
|
|
nsPresContext *presContext = aNewStyleContext->PresContext();
|
|
|
|
if (!shouldAnimate) {
|
|
if (haveCurrentTransition) {
|
|
// We're in the middle of a transition, and just got a non-transition
|
|
// style change to something that we can't animate. This might happen
|
|
// because we got a non-transition style change changing to the current
|
|
// in-progress value (which is particularly easy to cause when we're
|
|
// currently in the 'transition-delay'). It also might happen because we
|
|
// just got a style change to a value that can't be interpolated.
|
|
AnimationPlayerPtrArray& players = aElementTransitions->mPlayers;
|
|
oldPT = nullptr; // Clear pointer so it doesn't dangle
|
|
players.RemoveElementAt(currentIndex);
|
|
aElementTransitions->UpdateAnimationGeneration(mPresContext);
|
|
|
|
if (players.IsEmpty()) {
|
|
aElementTransitions->Destroy();
|
|
// |aElementTransitions| is now a dangling pointer!
|
|
aElementTransitions = nullptr;
|
|
}
|
|
// GetAnimationRule already called RestyleForAnimation.
|
|
}
|
|
return;
|
|
}
|
|
|
|
const nsTimingFunction &tf = aTransition.GetTimingFunction();
|
|
float delay = aTransition.GetDelay();
|
|
float duration = aTransition.GetDuration();
|
|
if (duration < 0.0) {
|
|
// The spec says a negative duration is treated as zero.
|
|
duration = 0.0;
|
|
}
|
|
|
|
StyleAnimationValue startForReversingTest = startValue;
|
|
double reversePortion = 1.0;
|
|
|
|
// If the new transition reverses an existing one, we'll need to
|
|
// handle the timing differently.
|
|
if (haveCurrentTransition &&
|
|
!oldPT->IsFinishedTransition() &&
|
|
oldPT->mStartForReversingTest == endValue) {
|
|
// Compute the appropriate negative transition-delay such that right
|
|
// now we'd end up at the current position.
|
|
double valuePortion =
|
|
oldPT->CurrentValuePortion() * oldPT->mReversePortion +
|
|
(1.0 - oldPT->mReversePortion);
|
|
// A timing function with negative y1 (or y2!) might make
|
|
// valuePortion negative. In this case, we still want to apply our
|
|
// reversing logic based on relative distances, not make duration
|
|
// negative.
|
|
if (valuePortion < 0.0) {
|
|
valuePortion = -valuePortion;
|
|
}
|
|
// A timing function with y2 (or y1!) greater than one might
|
|
// advance past its terminal value. It's probably a good idea to
|
|
// clamp valuePortion to be at most one to preserve the invariant
|
|
// that a transition will complete within at most its specified
|
|
// time.
|
|
if (valuePortion > 1.0) {
|
|
valuePortion = 1.0;
|
|
}
|
|
|
|
// Negative delays are essentially part of the transition
|
|
// function, so reduce them along with the duration, but don't
|
|
// reduce positive delays.
|
|
if (delay < 0.0f) {
|
|
delay *= valuePortion;
|
|
}
|
|
|
|
duration *= valuePortion;
|
|
|
|
startForReversingTest = oldPT->Properties()[0].mSegments[0].mToValue;
|
|
reversePortion = valuePortion;
|
|
}
|
|
|
|
AnimationTiming timing;
|
|
timing.mIterationDuration = TimeDuration::FromMilliseconds(duration);
|
|
timing.mDelay = TimeDuration::FromMilliseconds(delay);
|
|
timing.mIterationCount = 1;
|
|
timing.mDirection = NS_STYLE_ANIMATION_DIRECTION_NORMAL;
|
|
timing.mFillMode = NS_STYLE_ANIMATION_FILL_MODE_BACKWARDS;
|
|
|
|
nsRefPtr<ElementPropertyTransition> pt =
|
|
new ElementPropertyTransition(aElement->OwnerDoc(), aElement,
|
|
aNewStyleContext->GetPseudoType(), timing);
|
|
pt->mStartForReversingTest = startForReversingTest;
|
|
pt->mReversePortion = reversePortion;
|
|
|
|
AnimationProperty& prop = *pt->Properties().AppendElement();
|
|
prop.mProperty = aProperty;
|
|
|
|
AnimationPropertySegment& segment = *prop.mSegments.AppendElement();
|
|
segment.mFromValue = startValue;
|
|
segment.mToValue = endValue;
|
|
segment.mFromKey = 0;
|
|
segment.mToKey = 1;
|
|
segment.mTimingFunction.Init(tf);
|
|
|
|
nsRefPtr<CSSTransitionPlayer> player = new CSSTransitionPlayer(timeline);
|
|
player->PlayFromStyle();
|
|
player->SetSource(pt);
|
|
|
|
if (!aElementTransitions) {
|
|
aElementTransitions =
|
|
GetAnimationPlayers(aElement, aNewStyleContext->GetPseudoType(), true);
|
|
if (!aElementTransitions) {
|
|
NS_WARNING("allocating CommonAnimationManager failed");
|
|
return;
|
|
}
|
|
}
|
|
|
|
AnimationPlayerPtrArray& players = aElementTransitions->mPlayers;
|
|
#ifdef DEBUG
|
|
for (size_t i = 0, i_end = players.Length(); i < i_end; ++i) {
|
|
NS_ABORT_IF_FALSE(players[i]->GetSource() &&
|
|
players[i]->GetSource()->Properties().Length() == 1,
|
|
"Should have one animation property for a transition");
|
|
NS_ABORT_IF_FALSE(i == currentIndex ||
|
|
(players[i]->GetSource() &&
|
|
players[i]->GetSource()->Properties()[0].mProperty
|
|
!= aProperty),
|
|
"duplicate transitions for property");
|
|
}
|
|
#endif
|
|
if (haveCurrentTransition) {
|
|
players[currentIndex] = player;
|
|
} else {
|
|
if (!players.AppendElement(player)) {
|
|
NS_WARNING("out of memory");
|
|
return;
|
|
}
|
|
}
|
|
aElementTransitions->UpdateAnimationGeneration(mPresContext);
|
|
aElementTransitions->PostRestyleForAnimation(presContext);
|
|
|
|
*aStartedAny = true;
|
|
aWhichStarted->AddProperty(aProperty);
|
|
}
|
|
|
|
/*
|
|
* nsIStyleRuleProcessor implementation
|
|
*/
|
|
|
|
/* virtual */ size_t
|
|
nsTransitionManager::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
|
|
{
|
|
return CommonAnimationManager::SizeOfExcludingThis(aMallocSizeOf);
|
|
}
|
|
|
|
/* virtual */ size_t
|
|
nsTransitionManager::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const
|
|
{
|
|
return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
|
|
}
|
|
|
|
struct TransitionEventInfo {
|
|
nsCOMPtr<nsIContent> mElement;
|
|
InternalTransitionEvent mEvent;
|
|
|
|
TransitionEventInfo(nsIContent *aElement, nsCSSProperty aProperty,
|
|
TimeDuration aDuration, const nsAString& aPseudoElement)
|
|
: mElement(aElement)
|
|
, mEvent(true, NS_TRANSITION_END)
|
|
{
|
|
// XXX Looks like nobody initialize WidgetEvent::time
|
|
mEvent.propertyName =
|
|
NS_ConvertUTF8toUTF16(nsCSSProps::GetStringValue(aProperty));
|
|
mEvent.elapsedTime = aDuration.ToSeconds();
|
|
mEvent.pseudoElement = aPseudoElement;
|
|
}
|
|
|
|
// InternalTransitionEvent doesn't support copy-construction, so we need
|
|
// to ourselves in order to work with nsTArray
|
|
TransitionEventInfo(const TransitionEventInfo &aOther)
|
|
: mElement(aOther.mElement)
|
|
, mEvent(true, NS_TRANSITION_END)
|
|
{
|
|
mEvent.AssignTransitionEventData(aOther.mEvent, false);
|
|
}
|
|
};
|
|
|
|
/* virtual */ void
|
|
nsTransitionManager::WillRefresh(mozilla::TimeStamp aTime)
|
|
{
|
|
NS_ABORT_IF_FALSE(mPresContext,
|
|
"refresh driver should not notify additional observers "
|
|
"after pres context has been destroyed");
|
|
if (!mPresContext->GetPresShell()) {
|
|
// Someone might be keeping mPresContext alive past the point
|
|
// where it has been torn down; don't bother doing anything in
|
|
// this case. But do get rid of all our transitions so we stop
|
|
// triggering refreshes.
|
|
RemoveAllElementCollections();
|
|
return;
|
|
}
|
|
|
|
FlushTransitions(Can_Throttle);
|
|
}
|
|
|
|
void
|
|
nsTransitionManager::FlushTransitions(FlushFlags aFlags)
|
|
{
|
|
if (PR_CLIST_IS_EMPTY(&mElementCollections)) {
|
|
// no transitions, leave early
|
|
return;
|
|
}
|
|
|
|
nsTArray<TransitionEventInfo> events;
|
|
TimeStamp now = mPresContext->RefreshDriver()->MostRecentRefresh();
|
|
bool didThrottle = false;
|
|
// Trim transitions that have completed, post restyle events for frames that
|
|
// are still transitioning, and start transitions with delays.
|
|
{
|
|
PRCList *next = PR_LIST_HEAD(&mElementCollections);
|
|
while (next != &mElementCollections) {
|
|
AnimationPlayerCollection* collection =
|
|
static_cast<AnimationPlayerCollection*>(next);
|
|
next = PR_NEXT_LINK(next);
|
|
|
|
collection->Tick();
|
|
bool canThrottleTick = aFlags == Can_Throttle &&
|
|
collection->CanPerformOnCompositorThread(
|
|
AnimationPlayerCollection::CanAnimateFlags(0)) &&
|
|
collection->CanThrottleAnimation(now);
|
|
|
|
NS_ABORT_IF_FALSE(collection->mElement->GetCrossShadowCurrentDoc() ==
|
|
mPresContext->Document(),
|
|
"Element::UnbindFromTree should have "
|
|
"destroyed the element transitions object");
|
|
|
|
size_t i = collection->mPlayers.Length();
|
|
NS_ABORT_IF_FALSE(i != 0, "empty transitions list?");
|
|
bool transitionStartedOrEnded = false;
|
|
do {
|
|
--i;
|
|
AnimationPlayer* player = collection->mPlayers[i];
|
|
if (player->GetSource()->IsFinishedTransition()) {
|
|
// Actually remove transitions one throttle-able cycle after their
|
|
// completion. We only clear on a throttle-able cycle because that
|
|
// means it is a regular restyle tick and thus it is safe to discard
|
|
// the transition. If the flush is not throttle-able, we might still
|
|
// have new transitions left to process. See comment below.
|
|
if (aFlags == Can_Throttle) {
|
|
collection->mPlayers.RemoveElementAt(i);
|
|
}
|
|
} else {
|
|
MOZ_ASSERT(player->GetSource(),
|
|
"Transitions should have source content");
|
|
ComputedTiming computedTiming =
|
|
player->GetSource()->GetComputedTiming();
|
|
if (computedTiming.mPhase == ComputedTiming::AnimationPhase_After) {
|
|
MOZ_ASSERT(player->GetSource()->Properties().Length() == 1,
|
|
"Should have one animation property for a transition");
|
|
nsCSSProperty prop = player->GetSource()->Properties()[0].mProperty;
|
|
if (nsCSSProps::PropHasFlags(prop, CSS_PROPERTY_REPORT_OTHER_NAME))
|
|
{
|
|
prop = nsCSSProps::OtherNameFor(prop);
|
|
}
|
|
TimeDuration duration =
|
|
player->GetSource()->Timing().mIterationDuration;
|
|
events.AppendElement(
|
|
TransitionEventInfo(collection->mElement, prop,
|
|
duration,
|
|
collection->PseudoElement()));
|
|
|
|
// Leave this transition in the list for one more refresh
|
|
// cycle, since we haven't yet processed its style change, and
|
|
// if we also have (already, or will have from processing
|
|
// transitionend events or other refresh driver notifications)
|
|
// a non-animation style change that would affect it, we need
|
|
// to know not to start a new transition for the transition
|
|
// from the almost-completed value to the final value.
|
|
player->GetSource()->SetIsFinishedTransition();
|
|
collection->UpdateAnimationGeneration(mPresContext);
|
|
transitionStartedOrEnded = true;
|
|
} else if ((computedTiming.mPhase ==
|
|
ComputedTiming::AnimationPhase_Active) &&
|
|
canThrottleTick &&
|
|
!player->IsRunningOnCompositor()) {
|
|
// Start a transition with a delay where we should start the
|
|
// transition proper.
|
|
collection->UpdateAnimationGeneration(mPresContext);
|
|
transitionStartedOrEnded = true;
|
|
}
|
|
}
|
|
} while (i != 0);
|
|
|
|
// We need to restyle even if the transition rule no longer
|
|
// applies (in which case we just made it not apply).
|
|
MOZ_ASSERT(collection->mElementProperty ==
|
|
nsGkAtoms::transitionsProperty ||
|
|
collection->mElementProperty ==
|
|
nsGkAtoms::transitionsOfBeforeProperty ||
|
|
collection->mElementProperty ==
|
|
nsGkAtoms::transitionsOfAfterProperty,
|
|
"Unexpected element property; might restyle too much");
|
|
if (!canThrottleTick || transitionStartedOrEnded) {
|
|
collection->PostRestyleForAnimation(mPresContext);
|
|
} else {
|
|
didThrottle = true;
|
|
}
|
|
|
|
if (collection->mPlayers.IsEmpty()) {
|
|
collection->Destroy();
|
|
// |collection| is now a dangling pointer!
|
|
collection = nullptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (didThrottle) {
|
|
mPresContext->Document()->SetNeedStyleFlush();
|
|
}
|
|
|
|
for (uint32_t i = 0, i_end = events.Length(); i < i_end; ++i) {
|
|
TransitionEventInfo &info = events[i];
|
|
EventDispatcher::Dispatch(info.mElement, mPresContext, &info.mEvent);
|
|
|
|
if (!mPresContext) {
|
|
break;
|
|
}
|
|
}
|
|
}
|