2015-05-03 22:32:37 +03:00
|
|
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
2012-05-21 15:12:37 +04:00
|
|
|
/* 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/. */
|
2004-10-15 03:02:53 +04:00
|
|
|
|
2019-04-09 23:04:33 +03:00
|
|
|
#include "SVGAnimatedNumber.h"
|
2019-01-23 16:48:08 +03:00
|
|
|
|
2013-09-17 16:52:39 +04:00
|
|
|
#include "mozilla/Attributes.h"
|
2019-01-23 16:48:08 +03:00
|
|
|
#include "mozilla/SMILValue.h"
|
|
|
|
#include "mozilla/SVGContentUtils.h"
|
|
|
|
#include "nsContentUtils.h"
|
2018-12-24 22:24:45 +03:00
|
|
|
#include "SMILFloatType.h"
|
2019-01-24 00:48:00 +03:00
|
|
|
#include "SVGAttrTearoffTable.h"
|
2004-10-15 03:02:53 +04:00
|
|
|
|
2013-07-01 11:03:04 +04:00
|
|
|
using namespace mozilla::dom;
|
|
|
|
|
2019-04-09 23:04:33 +03:00
|
|
|
namespace mozilla {
|
|
|
|
|
2006-07-28 22:10:48 +04:00
|
|
|
/* Implementation */
|
2004-10-15 03:02:53 +04:00
|
|
|
|
2020-08-03 12:32:36 +03:00
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Helper class: AutoChangeNumberNotifier
|
|
|
|
// Stack-based helper class to ensure DidChangeNumber is called.
|
|
|
|
class MOZ_RAII AutoChangeNumberNotifier {
|
|
|
|
public:
|
|
|
|
AutoChangeNumberNotifier(SVGAnimatedNumber* aNumber, SVGElement* aSVGElement)
|
|
|
|
: mNumber(aNumber), mSVGElement(aSVGElement) {
|
|
|
|
MOZ_ASSERT(mNumber, "Expecting non-null number");
|
|
|
|
MOZ_ASSERT(mSVGElement, "Expecting non-null element");
|
|
|
|
}
|
|
|
|
|
|
|
|
~AutoChangeNumberNotifier() {
|
|
|
|
mSVGElement->DidChangeNumber(mNumber->mAttrEnum);
|
|
|
|
if (mNumber->mIsAnimated) {
|
|
|
|
mSVGElement->AnimationNeedsResample();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
SVGAnimatedNumber* const mNumber;
|
|
|
|
SVGElement* const mSVGElement;
|
|
|
|
};
|
|
|
|
|
2019-04-09 23:04:33 +03:00
|
|
|
static SVGAttrTearoffTable<SVGAnimatedNumber,
|
|
|
|
SVGAnimatedNumber::DOMAnimatedNumber>
|
2012-12-21 13:18:58 +04:00
|
|
|
sSVGAnimatedNumberTearoffTable;
|
2018-11-30 13:46:48 +03:00
|
|
|
|
2013-10-29 21:15:39 +04:00
|
|
|
static bool GetValueFromString(const nsAString& aString,
|
2011-09-29 10:19:26 +04:00
|
|
|
bool aPercentagesAllowed, float& aValue) {
|
2019-03-27 11:52:33 +03:00
|
|
|
bool success;
|
|
|
|
auto token = SVGContentUtils::GetAndEnsureOneToken(aString, success);
|
|
|
|
|
|
|
|
if (!success) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
RangedPtr<const char16_t> iter = SVGContentUtils::GetStartRangedPtr(token);
|
|
|
|
const RangedPtr<const char16_t> end = SVGContentUtils::GetEndRangedPtr(token);
|
2007-10-19 12:54:21 +04:00
|
|
|
|
2013-10-29 21:15:39 +04:00
|
|
|
if (!SVGContentUtils::ParseNumber(iter, end, aValue)) {
|
2013-10-01 11:50:40 +04:00
|
|
|
return false;
|
2010-12-05 23:33:31 +03:00
|
|
|
}
|
2013-10-01 11:50:40 +04:00
|
|
|
|
2013-10-29 21:15:39 +04:00
|
|
|
if (aPercentagesAllowed) {
|
|
|
|
const nsAString& units = Substring(iter.get(), end.get());
|
|
|
|
if (units.EqualsLiteral("%")) {
|
|
|
|
aValue /= 100;
|
|
|
|
return true;
|
|
|
|
}
|
2010-12-05 23:33:31 +03:00
|
|
|
}
|
2013-10-01 11:50:40 +04:00
|
|
|
|
2013-10-29 21:15:39 +04:00
|
|
|
return iter == end;
|
2010-12-05 23:33:31 +03:00
|
|
|
}
|
|
|
|
|
2019-04-09 23:04:33 +03:00
|
|
|
nsresult SVGAnimatedNumber::SetBaseValueString(const nsAString& aValueAsString,
|
|
|
|
SVGElement* aSVGElement) {
|
2010-12-05 23:33:31 +03:00
|
|
|
float val;
|
|
|
|
|
2013-10-01 11:50:40 +04:00
|
|
|
if (!GetValueFromString(aValueAsString,
|
|
|
|
aSVGElement->NumberAttrAllowsPercentage(mAttrEnum),
|
|
|
|
val)) {
|
|
|
|
return NS_ERROR_DOM_SYNTAX_ERR;
|
2010-12-05 23:33:31 +03:00
|
|
|
}
|
2007-10-19 12:54:21 +04:00
|
|
|
|
2010-02-11 22:41:48 +03:00
|
|
|
mBaseVal = val;
|
2011-10-17 18:59:28 +04:00
|
|
|
mIsBaseSet = true;
|
2010-02-11 22:41:48 +03:00
|
|
|
if (!mIsAnimated) {
|
|
|
|
mAnimVal = mBaseVal;
|
|
|
|
} else {
|
2009-12-29 09:34:27 +03:00
|
|
|
aSVGElement->AnimationNeedsResample();
|
|
|
|
}
|
|
|
|
|
2010-02-11 22:41:48 +03:00
|
|
|
// We don't need to call DidChange* here - we're only called by
|
2018-12-21 11:58:14 +03:00
|
|
|
// SVGElement::ParseAttribute under Element::SetAttr,
|
2010-02-11 22:41:48 +03:00
|
|
|
// which takes care of notifying.
|
2006-07-28 22:10:48 +04:00
|
|
|
return NS_OK;
|
|
|
|
}
|
2004-10-15 03:02:53 +04:00
|
|
|
|
2019-04-09 23:04:33 +03:00
|
|
|
void SVGAnimatedNumber::GetBaseValueString(nsAString& aValueAsString) {
|
2010-11-30 21:18:15 +03:00
|
|
|
aValueAsString.Truncate();
|
|
|
|
aValueAsString.AppendFloat(mBaseVal);
|
2006-07-28 22:10:48 +04:00
|
|
|
}
|
2004-10-15 03:02:53 +04:00
|
|
|
|
2019-04-09 23:04:33 +03:00
|
|
|
void SVGAnimatedNumber::SetBaseValue(float aValue, SVGElement* aSVGElement) {
|
2012-02-16 03:40:45 +04:00
|
|
|
if (mIsBaseSet && aValue == mBaseVal) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-08-03 12:32:36 +03:00
|
|
|
AutoChangeNumberNotifier notifier(this, aSVGElement);
|
|
|
|
|
2010-02-11 22:41:48 +03:00
|
|
|
mBaseVal = aValue;
|
2011-10-17 18:59:28 +04:00
|
|
|
mIsBaseSet = true;
|
2010-02-11 22:41:48 +03:00
|
|
|
if (!mIsAnimated) {
|
|
|
|
mAnimVal = mBaseVal;
|
2009-12-29 09:34:27 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-09 23:04:33 +03:00
|
|
|
void SVGAnimatedNumber::SetAnimValue(float aValue, SVGElement* aSVGElement) {
|
2012-06-02 03:53:06 +04:00
|
|
|
if (mIsAnimated && aValue == mAnimVal) {
|
|
|
|
return;
|
|
|
|
}
|
2009-12-29 09:34:27 +03:00
|
|
|
mAnimVal = aValue;
|
2011-10-17 18:59:28 +04:00
|
|
|
mIsAnimated = true;
|
2009-12-29 09:34:27 +03:00
|
|
|
aSVGElement->DidAnimateNumber(mAttrEnum);
|
2006-07-28 22:10:48 +04:00
|
|
|
}
|
2004-10-15 03:02:53 +04:00
|
|
|
|
2019-04-09 23:04:33 +03:00
|
|
|
already_AddRefed<DOMSVGAnimatedNumber> SVGAnimatedNumber::ToDOMAnimatedNumber(
|
2018-12-21 11:58:14 +03:00
|
|
|
SVGElement* aSVGElement) {
|
2015-10-18 08:24:48 +03:00
|
|
|
RefPtr<DOMAnimatedNumber> domAnimatedNumber =
|
2012-12-21 13:18:58 +04:00
|
|
|
sSVGAnimatedNumberTearoffTable.GetTearoff(this);
|
|
|
|
if (!domAnimatedNumber) {
|
|
|
|
domAnimatedNumber = new DOMAnimatedNumber(this, aSVGElement);
|
|
|
|
sSVGAnimatedNumberTearoffTable.AddTearoff(this, domAnimatedNumber);
|
|
|
|
}
|
2006-07-28 22:10:48 +04:00
|
|
|
|
2013-02-12 14:10:24 +04:00
|
|
|
return domAnimatedNumber.forget();
|
|
|
|
}
|
|
|
|
|
2019-04-09 23:04:33 +03:00
|
|
|
SVGAnimatedNumber::DOMAnimatedNumber::~DOMAnimatedNumber() {
|
2012-12-21 13:18:58 +04:00
|
|
|
sSVGAnimatedNumberTearoffTable.RemoveTearoff(mVal);
|
|
|
|
}
|
|
|
|
|
2019-04-09 23:04:33 +03:00
|
|
|
UniquePtr<SMILAttr> SVGAnimatedNumber::ToSMILAttr(SVGElement* aSVGElement) {
|
2017-03-30 07:10:07 +03:00
|
|
|
return MakeUnique<SMILNumber>(this, aSVGElement);
|
2009-12-29 09:34:27 +03:00
|
|
|
}
|
|
|
|
|
2019-04-09 23:04:33 +03:00
|
|
|
nsresult SVGAnimatedNumber::SMILNumber::ValueFromString(
|
2009-12-29 09:34:27 +03:00
|
|
|
const nsAString& aStr,
|
2019-01-23 16:48:08 +03:00
|
|
|
const mozilla::dom::SVGAnimationElement* /*aSrcElement*/, SMILValue& aValue,
|
|
|
|
bool& aPreventCachingOfSandwich) const {
|
2009-12-29 09:34:27 +03:00
|
|
|
float value;
|
|
|
|
|
2013-10-01 11:50:40 +04:00
|
|
|
if (!GetValueFromString(
|
|
|
|
aStr, mSVGElement->NumberAttrAllowsPercentage(mVal->mAttrEnum),
|
|
|
|
value)) {
|
|
|
|
return NS_ERROR_DOM_SYNTAX_ERR;
|
2009-12-29 09:34:27 +03:00
|
|
|
}
|
|
|
|
|
2019-01-23 16:48:08 +03:00
|
|
|
SMILValue val(SMILFloatType::Singleton());
|
2009-12-29 09:34:27 +03:00
|
|
|
val.mU.mDouble = value;
|
|
|
|
aValue = val;
|
2011-10-17 18:59:28 +04:00
|
|
|
aPreventCachingOfSandwich = false;
|
2009-12-29 09:34:27 +03:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2019-04-09 23:04:33 +03:00
|
|
|
SMILValue SVGAnimatedNumber::SMILNumber::GetBaseValue() const {
|
2019-01-23 16:48:08 +03:00
|
|
|
SMILValue val(SMILFloatType::Singleton());
|
2009-12-29 09:34:27 +03:00
|
|
|
val.mU.mDouble = mVal->mBaseVal;
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2019-04-09 23:04:33 +03:00
|
|
|
void SVGAnimatedNumber::SMILNumber::ClearAnimValue() {
|
2009-12-29 09:34:27 +03:00
|
|
|
if (mVal->mIsAnimated) {
|
2011-10-17 18:59:28 +04:00
|
|
|
mVal->mIsAnimated = false;
|
2012-03-03 13:21:09 +04:00
|
|
|
mVal->mAnimVal = mVal->mBaseVal;
|
|
|
|
mSVGElement->DidAnimateNumber(mVal->mAttrEnum);
|
2009-12-29 09:34:27 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-09 23:04:33 +03:00
|
|
|
nsresult SVGAnimatedNumber::SMILNumber::SetAnimValue(const SMILValue& aValue) {
|
2018-12-24 22:24:45 +03:00
|
|
|
NS_ASSERTION(aValue.mType == SMILFloatType::Singleton(),
|
2009-12-29 09:34:27 +03:00
|
|
|
"Unexpected type to assign animated value");
|
2018-12-24 22:24:45 +03:00
|
|
|
if (aValue.mType == SMILFloatType::Singleton()) {
|
2009-12-29 09:34:27 +03:00
|
|
|
mVal->SetAnimValue(float(aValue.mU.mDouble), mSVGElement);
|
|
|
|
}
|
|
|
|
return NS_OK;
|
|
|
|
}
|
2019-04-09 23:04:33 +03:00
|
|
|
|
|
|
|
} // namespace mozilla
|