From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- dom/smil/SMILCompositor.h | 132 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 132 insertions(+) create mode 100644 dom/smil/SMILCompositor.h (limited to 'dom/smil/SMILCompositor.h') diff --git a/dom/smil/SMILCompositor.h b/dom/smil/SMILCompositor.h new file mode 100644 index 0000000000..5f987d5854 --- /dev/null +++ b/dom/smil/SMILCompositor.h @@ -0,0 +1,132 @@ +/* -*- 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/. */ + +#ifndef DOM_SMIL_SMILCOMPOSITOR_H_ +#define DOM_SMIL_SMILCOMPOSITOR_H_ + +#include + +#include "PLDHashTable.h" +#include "SMILTargetIdentifier.h" +#include "mozilla/SMILAnimationFunction.h" +#include "mozilla/SMILCompositorTable.h" +#include "mozilla/UniquePtr.h" +#include "nsCSSPropertyID.h" +#include "nsString.h" +#include "nsTHashtable.h" + +namespace mozilla { + +class ComputedStyle; + +//---------------------------------------------------------------------- +// SMILCompositor +// +// Performs the composition of the animation sandwich by combining the results +// of a series animation functions according to the rules of SMIL composition +// including prioritising animations. + +class SMILCompositor : public PLDHashEntryHdr { + public: + using KeyType = SMILTargetIdentifier; + using KeyTypeRef = const KeyType&; + using KeyTypePointer = const KeyType*; + + explicit SMILCompositor(KeyTypePointer aKey) + : mKey(*aKey), mForceCompositing(false) {} + SMILCompositor(SMILCompositor&& toMove) noexcept + : PLDHashEntryHdr(std::move(toMove)), + mKey(std::move(toMove.mKey)), + mAnimationFunctions(std::move(toMove.mAnimationFunctions)), + mForceCompositing(false) {} + + // PLDHashEntryHdr methods + KeyTypeRef GetKey() const { return mKey; } + bool KeyEquals(KeyTypePointer aKey) const; + static KeyTypePointer KeyToPointer(KeyTypeRef aKey) { return &aKey; } + static PLDHashNumber HashKey(KeyTypePointer aKey); + enum { ALLOW_MEMMOVE = false }; + + // Adds the given animation function to this Compositor's list of functions + void AddAnimationFunction(SMILAnimationFunction* aFunc); + + // Composes the attribute's current value with the list of animation + // functions, and assigns the resulting value to this compositor's target + // attribute. If a change is made that might produce style updates, + // aMightHavePendingStyleUpdates is set to true. Otherwise it is not modified. + void ComposeAttribute(bool& aMightHavePendingStyleUpdates); + + // Clears animation effects on my target attribute + void ClearAnimationEffects(); + + // Cycle-collection support + void Traverse(nsCycleCollectionTraversalCallback* aCallback); + + // Toggles a bit that will force us to composite (bypassing early-return + // optimizations) when we hit ComposeAttribute. + void ToggleForceCompositing() { mForceCompositing = true; } + + // Transfers |aOther|'s mCachedBaseValue to |this| + void StealCachedBaseValue(SMILCompositor* aOther) { + mCachedBaseValue = std::move(aOther->mCachedBaseValue); + } + + bool HasSameNumberOfAnimationFunctionsAs(const SMILCompositor& aOther) const { + return mAnimationFunctions.Length() == aOther.mAnimationFunctions.Length(); + } + + private: + // Create a SMILAttr for my target, on the heap. + // + // @param aBaseComputedStyle An optional ComputedStyle which, if set, will be + // used when fetching the base style. + UniquePtr CreateSMILAttr(const ComputedStyle* aBaseComputedStyle); + + // Returns the CSS property this compositor should animate, or + // eCSSProperty_UNKNOWN if this compositor does not animate a CSS property. + nsCSSPropertyID GetCSSPropertyToAnimate() const; + + // Returns true if we might need to refer to base styles (i.e. we are + // targeting a CSS property and have one or more animation functions that + // don't just replace the underlying value). + // + // This might return true in some cases where we don't actually need the base + // style since it doesn't build up the animation sandwich to check if the + // functions that appear to need the base style are actually replaced by + // a function further up the stack. + bool MightNeedBaseStyle() const; + + // Finds the index of the first function that will affect our animation + // sandwich. Also toggles the 'mForceCompositing' flag if it finds that any + // (used) functions have changed. + uint32_t GetFirstFuncToAffectSandwich(); + + // If the passed-in base value differs from our cached base value, this + // method updates the cached value (and toggles the 'mForceCompositing' flag) + void UpdateCachedBaseValue(const SMILValue& aBaseValue); + + // The hash key (tuple of element and attributeName) + KeyType mKey; + + // Hash Value: List of animation functions that animate the specified attr + nsTArray mAnimationFunctions; + + // Member data for detecting when we need to force-recompose + // --------------------------------------------------------- + // Flag for tracking whether we need to compose. Initialized to false, but + // gets flipped to true if we detect that something has changed. + bool mForceCompositing; + + // Cached base value, so we can detect & force-recompose when it changes + // from one sample to the next. (SMILAnimationController moves this + // forward from the previous sample's compositor by calling + // StealCachedBaseValue.) + SMILValue mCachedBaseValue; +}; + +} // namespace mozilla + +#endif // DOM_SMIL_SMILCOMPOSITOR_H_ -- cgit v1.2.3