Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
#ifndef DOM_SVG_SVGANIMATEDLENGTH_H_
#define DOM_SVG_SVGANIMATEDLENGTH_H_
#include "mozilla/Attributes.h"
#include "mozilla/SMILAttr.h"
#include "mozilla/SVGContentUtils.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/dom/SVGLengthBinding.h"
#include "mozilla/dom/SVGElement.h"
#include "nsError.h"
struct GeckoFontMetrics;
class nsPresContext;
class nsFontMetrics;
class mozAutoDocUpdate;
class nsIFrame;
namespace mozilla {
class AutoChangeLengthNotifier;
class SMILValue;
namespace dom {
class DOMSVGAnimatedLength;
class DOMSVGLength;
class SVGAnimationElement;
class SVGViewportElement;
class UserSpaceMetrics {
public:
enum class Type : uint32_t { This, Root };
static GeckoFontMetrics DefaultFontMetrics();
static GeckoFontMetrics GetFontMetrics(const Element* aElement);
static WritingMode GetWritingMode(const Element* aElement);
static float GetZoom(const Element* aElement);
static CSSSize GetCSSViewportSizeFromContext(const nsPresContext* aContext);
virtual ~UserSpaceMetrics() = default;
virtual float GetEmLength(Type aType) const = 0;
virtual float GetZoom() const = 0;
virtual float GetRootZoom() const = 0;
float GetExLength(Type aType) const;
float GetChSize(Type aType) const;
float GetIcWidth(Type aType) const;
float GetCapHeight(Type aType) const;
virtual float GetAxisLength(uint8_t aCtxType) const = 0;
virtual CSSSize GetCSSViewportSize() const = 0;
virtual float GetLineHeight(Type aType) const = 0;
protected:
virtual GeckoFontMetrics GetFontMetricsForType(Type aType) const = 0;
virtual WritingMode GetWritingModeForType(Type aType) const = 0;
};
class UserSpaceMetricsWithSize : public UserSpaceMetrics {
public:
virtual gfx::Size GetSize() const = 0;
float GetAxisLength(uint8_t aCtxType) const override;
};
class SVGElementMetrics final : public UserSpaceMetrics {
public:
explicit SVGElementMetrics(const SVGElement* aSVGElement,
const SVGViewportElement* aCtx = nullptr);
float GetEmLength(Type aType) const override {
return SVGContentUtils::GetFontSize(GetElementForType(aType));
}
float GetAxisLength(uint8_t aCtxType) const override;
CSSSize GetCSSViewportSize() const override;
float GetLineHeight(Type aType) const override;
float GetZoom() const override;
float GetRootZoom() const override;
private:
bool EnsureCtx() const;
const Element* GetElementForType(Type aType) const;
GeckoFontMetrics GetFontMetricsForType(Type aType) const override;
WritingMode GetWritingModeForType(Type aType) const override;
const SVGElement* mSVGElement;
mutable const SVGViewportElement* mCtx;
};
class NonSVGFrameUserSpaceMetrics final : public UserSpaceMetricsWithSize {
public:
explicit NonSVGFrameUserSpaceMetrics(nsIFrame* aFrame);
float GetEmLength(Type aType) const override;
gfx::Size GetSize() const override;
CSSSize GetCSSViewportSize() const override;
float GetLineHeight(Type aType) const override;
float GetZoom() const override;
float GetRootZoom() const override;
private:
GeckoFontMetrics GetFontMetricsForType(Type aType) const override;
WritingMode GetWritingModeForType(Type aType) const override;
nsIFrame* mFrame;
};
} // namespace dom
class SVGAnimatedLength {
friend class AutoChangeLengthNotifier;
friend class dom::DOMSVGAnimatedLength;
friend class dom::DOMSVGLength;
using DOMSVGLength = dom::DOMSVGLength;
using SVGElement = dom::SVGElement;
using SVGViewportElement = dom::SVGViewportElement;
using UserSpaceMetrics = dom::UserSpaceMetrics;
public:
void Init(uint8_t aCtxType = SVGContentUtils::XY, uint8_t aAttrEnum = 0xff,
float aValue = 0,
uint8_t aUnitType = dom::SVGLength_Binding::SVG_LENGTHTYPE_NUMBER) {
mAnimVal = mBaseVal = aValue;
mBaseUnitType = mAnimUnitType = aUnitType;
mAttrEnum = aAttrEnum;
mCtxType = aCtxType;
mIsAnimated = false;
mIsBaseSet = false;
}
SVGAnimatedLength& operator=(const SVGAnimatedLength& aLength) {
mBaseVal = aLength.mBaseVal;
mAnimVal = aLength.mAnimVal;
mBaseUnitType = aLength.mBaseUnitType;
mAnimUnitType = aLength.mAnimUnitType;
mIsAnimated = aLength.mIsAnimated;
mIsBaseSet = aLength.mIsBaseSet;
return *this;
}
nsresult SetBaseValueString(const nsAString& aValue, SVGElement* aSVGElement,
bool aDoSetAttr);
void GetBaseValueString(nsAString& aValue) const;
void GetAnimValueString(nsAString& aValue) const;
float GetBaseValue(const SVGElement* aSVGElement) const {
return mBaseVal * GetPixelsPerUnit(aSVGElement, mBaseUnitType);
}
float GetAnimValue(const SVGElement* aSVGElement) const {
return mAnimVal * GetPixelsPerUnit(aSVGElement, mAnimUnitType);
}
float GetAnimValueWithZoom(const SVGElement* aSVGElement) const {
return mAnimVal * GetPixelsPerUnitWithZoom(aSVGElement, mAnimUnitType);
}
float GetAnimValueWithZoom(nsIFrame* aFrame) const {
return mAnimVal * GetPixelsPerUnitWithZoom(aFrame, mAnimUnitType);
}
float GetAnimValueWithZoom(const SVGViewportElement* aCtx) const {
return mAnimVal * GetPixelsPerUnitWithZoom(aCtx, mAnimUnitType);
}
float GetAnimValueWithZoom(const UserSpaceMetrics& aMetrics) const {
return mAnimVal * GetPixelsPerUnitWithZoom(aMetrics, mAnimUnitType);
}
uint8_t GetCtxType() const { return mCtxType; }
uint8_t GetBaseUnitType() const { return mBaseUnitType; }
uint8_t GetAnimUnitType() const { return mAnimUnitType; }
bool IsPercentage() const {
return mAnimUnitType == dom::SVGLength_Binding::SVG_LENGTHTYPE_PERCENTAGE;
}
float GetAnimValInSpecifiedUnits() const { return mAnimVal; }
float GetBaseValInSpecifiedUnits() const { return mBaseVal; }
bool HasBaseVal() const { return mIsBaseSet; }
// Returns true if the animated value of this length has been explicitly
// set (either by animation, or by taking on the base value which has been
// explicitly set by markup or a DOM call), false otherwise.
// If this returns false, the animated value is still valid, that is,
// usable, and represents the default base value of the attribute.
bool IsExplicitlySet() const { return mIsAnimated || mIsBaseSet; }
bool IsAnimated() const { return mIsAnimated; }
already_AddRefed<dom::DOMSVGAnimatedLength> ToDOMAnimatedLength(
SVGElement* aSVGElement);
UniquePtr<SMILAttr> ToSMILAttr(SVGElement* aSVGElement);
private:
float mAnimVal;
float mBaseVal;
uint8_t mBaseUnitType;
uint8_t mAnimUnitType;
uint8_t mAttrEnum : 6; // element specified tracking for attribute
uint8_t mCtxType : 2; // X, Y or Unspecified
bool mIsAnimated : 1;
bool mIsBaseSet : 1;
// These APIs returns the number of user-unit pixels per unit of the
// given type, in a given context (frame/element/etc).
float GetPixelsPerUnit(const SVGElement* aSVGElement,
uint8_t aUnitType) const;
float GetPixelsPerUnitWithZoom(nsIFrame* aFrame, uint8_t aUnitType) const;
float GetPixelsPerUnitWithZoom(const UserSpaceMetrics& aMetrics,
uint8_t aUnitType) const;
float GetPixelsPerUnitWithZoom(const SVGElement* aSVGElement,
uint8_t aUnitType) const;
float GetPixelsPerUnitWithZoom(const SVGViewportElement* aCtx,
uint8_t aUnitType) const;
// SetBaseValue and SetAnimValue set the value in user units. This may fail
// if unit conversion fails e.g. conversion to ex or em units where the
// font-size is 0.
// SetBaseValueInSpecifiedUnits and SetAnimValueInSpecifiedUnits do not
// perform unit conversion and are therefore infallible.
nsresult SetBaseValue(float aValue, SVGElement* aSVGElement, bool aDoSetAttr);
void SetBaseValueInSpecifiedUnits(float aValue, SVGElement* aSVGElement,
bool aDoSetAttr);
void SetAnimValue(float aValue, uint16_t aUnitType, SVGElement* aSVGElement);
void SetAnimValueInSpecifiedUnits(float aValue, SVGElement* aSVGElement);
nsresult NewValueSpecifiedUnits(uint16_t aUnitType,
float aValueInSpecifiedUnits,
SVGElement* aSVGElement);
nsresult ConvertToSpecifiedUnits(uint16_t aUnitType, SVGElement* aSVGElement);
already_AddRefed<DOMSVGLength> ToDOMBaseVal(SVGElement* aSVGElement);
already_AddRefed<DOMSVGLength> ToDOMAnimVal(SVGElement* aSVGElement);
public:
struct SMILLength : public SMILAttr {
public:
SMILLength(SVGAnimatedLength* aVal, SVGElement* aSVGElement)
: mVal(aVal), mSVGElement(aSVGElement) {}
// These will stay alive because a SMILAttr only lives as long
// as the Compositing step, and DOM elements don't get a chance to
// die during that.
SVGAnimatedLength* mVal;
SVGElement* mSVGElement;
// SMILAttr methods
nsresult ValueFromString(const nsAString& aStr,
const dom::SVGAnimationElement* aSrcElement,
SMILValue& aValue,
bool& aPreventCachingOfSandwich) const override;
SMILValue GetBaseValue() const override;
void ClearAnimValue() override;
nsresult SetAnimValue(const SMILValue& aValue) override;
};
};
/**
* This class is used by the SMIL code when a length is to be stored in a
* SMILValue instance. Since SMILValue objects may be cached, it is necessary
* for us to hold a strong reference to our element so that it doesn't
* disappear out from under us if, say, the element is removed from the DOM
* tree.
*/
class SVGLengthAndInfo {
public:
SVGLengthAndInfo() = default;
explicit SVGLengthAndInfo(dom::SVGElement* aElement)
: mElement(do_GetWeakReference(aElement->AsNode())) {}
void SetInfo(dom::SVGElement* aElement) {
mElement = do_GetWeakReference(aElement->AsNode());
}
dom::SVGElement* Element() const {
nsCOMPtr<nsIContent> e = do_QueryReferent(mElement);
return static_cast<dom::SVGElement*>(e.get());
}
bool operator==(const SVGLengthAndInfo& rhs) const {
return mValue == rhs.mValue && mUnitType == rhs.mUnitType &&
mCtxType == rhs.mCtxType;
}
float Value() const { return mValue; }
uint8_t UnitType() const { return mUnitType; }
void CopyFrom(const SVGLengthAndInfo& rhs) {
mElement = rhs.mElement;
mValue = rhs.mValue;
mUnitType = rhs.mUnitType;
mCtxType = rhs.mCtxType;
}
float ConvertUnits(const SVGLengthAndInfo& aTo) const;
float ValueInPixels(const dom::UserSpaceMetrics& aMetrics) const;
void Add(const SVGLengthAndInfo& aValueToAdd, uint32_t aCount);
static void Interpolate(const SVGLengthAndInfo& aStart,
const SVGLengthAndInfo& aEnd, double aUnitDistance,
SVGLengthAndInfo& aResult);
/**
* Enables SVGAnimatedLength values to be copied into SVGLengthAndInfo
* objects. Note that callers should also call SetInfo() when using this
* method!
*/
void CopyBaseFrom(const SVGAnimatedLength& rhs) {
mValue = rhs.GetBaseValInSpecifiedUnits();
mUnitType = rhs.GetBaseUnitType();
mCtxType = rhs.GetCtxType();
}
void Set(float aValue, uint8_t aUnitType, uint8_t aCtxType) {
mValue = aValue;
mUnitType = aUnitType;
mCtxType = aCtxType;
}
private:
// We must keep a weak reference to our element because we may belong to a
// cached baseVal SMILValue. See the comments starting at:
nsWeakPtr mElement;
float mValue = 0.0f;
uint8_t mUnitType = dom::SVGLength_Binding::SVG_LENGTHTYPE_NUMBER;
uint8_t mCtxType = SVGContentUtils::XY;
};
} // namespace mozilla
#endif // DOM_SVG_SVGANIMATEDLENGTH_H_