dom/svg/SVGAnimatedLength.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "SVGAnimatedLength.h"
   8
   9 #include "mozAutoDocUpdate.h"
  10 #include "mozilla/ArrayUtils.h"
  11 #include "mozilla/Maybe.h"
  12 #include "mozilla/SMILValue.h"
  13 #include "mozilla/SVGIntegrationUtils.h"
  14 #include "mozilla/dom/SVGViewportElement.h"
  15 #include "DOMSVGAnimatedLength.h"
  16 #include "DOMSVGLength.h"
  17 #include "LayoutLogging.h"
  18 #include "nsContentUtils.h"
  19 #include "nsIFrame.h"
  20 #include "nsTextFormatter.h"
  21 #include "SMILFloatType.h"
  22 #include "SVGAttrTearoffTable.h"
  23
  24 using namespace mozilla::dom;
  25
  26 namespace mozilla {
  27
  28 //----------------------------------------------------------------------
  29 // Helper class: AutoChangeLengthNotifier
  30 // Stack-based helper class to pair calls to WillChangeLength and
  31 // DidChangeLength.
  32 class MOZ_RAII AutoChangeLengthNotifier {
  33  public:
  34   AutoChangeLengthNotifier(SVGAnimatedLength* aLength, SVGElement* aSVGElement,
  35                            bool aDoSetAttr = true)
  36       : mLength(aLength), mSVGElement(aSVGElement), mDoSetAttr(aDoSetAttr) {
  37     MOZ_ASSERT(mLength, "Expecting non-null length");
  38     MOZ_ASSERT(mSVGElement, "Expecting non-null element");
  39
  40     if (mDoSetAttr) {
  41       mUpdateBatch.emplace(aSVGElement->GetComposedDoc(), true);
  42       mEmptyOrOldValue =
  43           mSVGElement->WillChangeLength(mLength->mAttrEnum, mUpdateBatch.ref());
  44     }
  45   }
  46
  47   ~AutoChangeLengthNotifier() {
  48     if (mDoSetAttr) {
  49       mSVGElement->DidChangeLength(mLength->mAttrEnum, mEmptyOrOldValue,
  50                                    mUpdateBatch.ref());
  51     }
  52     if (mLength->mIsAnimated) {
  53       mSVGElement->AnimationNeedsResample();
  54     }
  55   }
  56
  57  private:
  58   SVGAnimatedLength* const mLength;
  59   SVGElement* const mSVGElement;
  60   Maybe<mozAutoDocUpdate> mUpdateBatch;
  61   nsAttrValue mEmptyOrOldValue;
  62   bool mDoSetAttr;
  63 };
  64
  65 static const nsStaticAtom* const unitMap[] = {
  66     nullptr, /* SVG_LENGTHTYPE_UNKNOWN */
  67     nullptr, /* SVG_LENGTHTYPE_NUMBER */
  68     nsGkAtoms::percentage,
  69     nsGkAtoms::em,
  70     nsGkAtoms::ex,
  71     nsGkAtoms::px,
  72     nsGkAtoms::cm,
  73     nsGkAtoms::mm,
  74     nsGkAtoms::in,
  75     nsGkAtoms::pt,
  76     nsGkAtoms::pc};
  77
  78 static SVGAttrTearoffTable<SVGAnimatedLength, DOMSVGAnimatedLength>
  79     sSVGAnimatedLengthTearoffTable;
  80
  81 /* Helper functions */
  82
  83 static bool IsValidUnitType(uint16_t unit) {
  84   return unit > SVGLength_Binding::SVG_LENGTHTYPE_UNKNOWN &&
  85          unit <= SVGLength_Binding::SVG_LENGTHTYPE_PC;
  86 }
  87
  88 static void GetUnitString(nsAString& unit, uint16_t unitType) {
  89   if (IsValidUnitType(unitType)) {
  90     if (unitMap[unitType]) {
  91       unitMap[unitType]->ToString(unit);
  92     }
  93     return;
  94   }
  95
  96   MOZ_ASSERT_UNREACHABLE("Unknown unit type");
  97 }
  98
  99 static uint16_t GetUnitTypeForString(const nsAString& unitStr) {
 100   if (unitStr.IsEmpty()) return SVGLength_Binding::SVG_LENGTHTYPE_NUMBER;
 101
 102   nsAtom* unitAtom = NS_GetStaticAtom(unitStr);
 103   if (unitAtom) {
 104     for (uint32_t i = 0; i < ArrayLength(unitMap); i++) {
 105       if (unitMap[i] == unitAtom) {
 106         return i;
 107       }
 108     }
 109   }
 110
 111   return SVGLength_Binding::SVG_LENGTHTYPE_UNKNOWN;
 112 }
 113
 114 static void GetValueString(nsAString& aValueAsString, float aValue,
 115                            uint16_t aUnitType) {
 116   nsTextFormatter::ssprintf(aValueAsString, u"%g", (double)aValue);
 117
 118   nsAutoString unitString;
 119   GetUnitString(unitString, aUnitType);
 120   aValueAsString.Append(unitString);
 121 }
 122
 123 static bool GetValueFromString(const nsAString& aString, float& aValue,
 124                                uint16_t* aUnitType) {
 125   bool success;
 126   auto token = SVGContentUtils::GetAndEnsureOneToken(aString, success);
 127
 128   if (!success) {
 129     return false;
 130   }
 131
 132   RangedPtr<const char16_t> iter = SVGContentUtils::GetStartRangedPtr(token);
 133   const RangedPtr<const char16_t> end = SVGContentUtils::GetEndRangedPtr(token);
 134
 135   if (!SVGContentUtils::ParseNumber(iter, end, aValue)) {
 136     return false;
 137   }
 138   const nsAString& units = Substring(iter.get(), end.get());
 139   *aUnitType = GetUnitTypeForString(units);
 140   return IsValidUnitType(*aUnitType);
 141 }
 142
 143 static float FixAxisLength(float aLength) {
 144   if (aLength == 0.0f) {
 145     LAYOUT_WARNING("zero axis length");
 146     return 1e-20f;
 147   }
 148   return aLength;
 149 }
 150
 151 SVGElementMetrics::SVGElementMetrics(SVGElement* aSVGElement,
 152                                      SVGViewportElement* aCtx)
 153     : mSVGElement(aSVGElement), mCtx(aCtx) {}
 154
 155 float SVGElementMetrics::GetEmLength() const {
 156   return SVGContentUtils::GetFontSize(mSVGElement);
 157 }
 158
 159 float SVGElementMetrics::GetExLength() const {
 160   return SVGContentUtils::GetFontXHeight(mSVGElement);
 161 }
 162
 163 float SVGElementMetrics::GetAxisLength(uint8_t aCtxType) const {
 164   if (!EnsureCtx()) {
 165     return 1;
 166   }
 167
 168   return FixAxisLength(mCtx->GetLength(aCtxType));
 169 }
 170
 171 bool SVGElementMetrics::EnsureCtx() const {
 172   if (!mCtx && mSVGElement) {
 173     mCtx = mSVGElement->GetCtx();
 174     if (!mCtx && mSVGElement->IsSVGElement(nsGkAtoms::svg)) {
 175       auto* e = static_cast<SVGViewportElement*>(mSVGElement);
 176
 177       if (!e->IsInner()) {
 178         // mSVGElement must be the outer svg element
 179         mCtx = e;
 180       }
 181     }
 182   }
 183   return mCtx != nullptr;
 184 }
 185
 186 NonSVGFrameUserSpaceMetrics::NonSVGFrameUserSpaceMetrics(nsIFrame* aFrame)
 187     : mFrame(aFrame) {}
 188
 189 float NonSVGFrameUserSpaceMetrics::GetEmLength() const {
 190   return SVGContentUtils::GetFontSize(mFrame);
 191 }
 192
 193 float NonSVGFrameUserSpaceMetrics::GetExLength() const {
 194   return SVGContentUtils::GetFontXHeight(mFrame);
 195 }
 196
 197 gfx::Size NonSVGFrameUserSpaceMetrics::GetSize() const {
 198   return SVGIntegrationUtils::GetSVGCoordContextForNonSVGFrame(mFrame);
 199 }
 200
 201 float UserSpaceMetricsWithSize::GetAxisLength(uint8_t aCtxType) const {
 202   gfx::Size size = GetSize();
 203   float length;
 204   switch (aCtxType) {
 205     case SVGContentUtils::X:
 206       length = size.width;
 207       break;
 208     case SVGContentUtils::Y:
 209       length = size.height;
 210       break;
 211     case SVGContentUtils::XY:
 212       length =
 213           SVGContentUtils::ComputeNormalizedHypotenuse(size.width, size.height);
 214       break;
 215     default:
 216       MOZ_ASSERT_UNREACHABLE("Unknown axis type");
 217       length = 1;
 218       break;
 219   }
 220   return FixAxisLength(length);
 221 }
 222
 223 float SVGAnimatedLength::GetPixelsPerUnit(SVGElement* aSVGElement,
 224                                           uint8_t aUnitType) const {
 225   return GetPixelsPerUnit(SVGElementMetrics(aSVGElement), aUnitType);
 226 }
 227
 228 float SVGAnimatedLength::GetPixelsPerUnit(SVGViewportElement* aCtx,
 229                                           uint8_t aUnitType) const {
 230   return GetPixelsPerUnit(SVGElementMetrics(aCtx, aCtx), aUnitType);
 231 }
 232
 233 float SVGAnimatedLength::GetPixelsPerUnit(nsIFrame* aFrame,
 234                                           uint8_t aUnitType) const {
 235   nsIContent* content = aFrame->GetContent();
 236   if (content->IsSVGElement()) {
 237     return GetPixelsPerUnit(
 238         SVGElementMetrics(static_cast<SVGElement*>(content)), aUnitType);
 239   }
 240   return GetPixelsPerUnit(NonSVGFrameUserSpaceMetrics(aFrame), aUnitType);
 241 }
 242
 243 // See https://www.w3.org/TR/css-values-3/#absolute-lengths
 244 static const float DPI = 96.0f;
 245
 246 bool UserSpaceMetrics::ResolveAbsoluteUnit(uint8_t aUnitType, float& aRes) {
 247   switch (aUnitType) {
 248     case SVGLength_Binding::SVG_LENGTHTYPE_NUMBER:
 249     case SVGLength_Binding::SVG_LENGTHTYPE_PX:
 250       aRes = 1;
 251       break;
 252     case SVGLength_Binding::SVG_LENGTHTYPE_MM:
 253       aRes = DPI / MM_PER_INCH_FLOAT;
 254       break;
 255     case SVGLength_Binding::SVG_LENGTHTYPE_CM:
 256       aRes = 10.0f * DPI / MM_PER_INCH_FLOAT;
 257       break;
 258     case SVGLength_Binding::SVG_LENGTHTYPE_IN:
 259       aRes = DPI;
 260       break;
 261     case SVGLength_Binding::SVG_LENGTHTYPE_PT:
 262       aRes = DPI / POINTS_PER_INCH_FLOAT;
 263       break;
 264     case SVGLength_Binding::SVG_LENGTHTYPE_PC:
 265       aRes = 12.0f * DPI / POINTS_PER_INCH_FLOAT;
 266       break;
 267     default:
 268       return false;
 269   }
 270   return true;
 271 }
 272
 273 float SVGAnimatedLength::GetPixelsPerUnit(const UserSpaceMetrics& aMetrics,
 274                                           uint8_t aUnitType) const {
 275   float res;
 276   if (UserSpaceMetrics::ResolveAbsoluteUnit(aUnitType, res)) {
 277     return res;
 278   }
 279   switch (aUnitType) {
 280     case SVGLength_Binding::SVG_LENGTHTYPE_PERCENTAGE:
 281       return aMetrics.GetAxisLength(mCtxType) / 100.0f;
 282     case SVGLength_Binding::SVG_LENGTHTYPE_EMS:
 283       return aMetrics.GetEmLength();
 284     case SVGLength_Binding::SVG_LENGTHTYPE_EXS:
 285       return aMetrics.GetExLength();
 286     default:
 287       MOZ_ASSERT_UNREACHABLE("Unknown unit type");
 288       return 0;
 289   }
 290 }
 291
 292 void SVGAnimatedLength::SetBaseValueInSpecifiedUnits(float aValue,
 293                                                      SVGElement* aSVGElement,
 294                                                      bool aDoSetAttr) {
 295   if (mIsBaseSet && mBaseVal == aValue) {
 296     return;
 297   }
 298
 299   AutoChangeLengthNotifier notifier(this, aSVGElement, aDoSetAttr);
 300
 301   mBaseVal = aValue;
 302   mIsBaseSet = true;
 303   if (!mIsAnimated) {
 304     mAnimVal = mBaseVal;
 305   }
 306 }
 307
 308 nsresult SVGAnimatedLength::ConvertToSpecifiedUnits(uint16_t unitType,
 309                                                     SVGElement* aSVGElement) {
 310   if (!IsValidUnitType(unitType)) return NS_ERROR_DOM_NOT_SUPPORTED_ERR;
 311
 312   if (mIsBaseSet && mSpecifiedUnitType == uint8_t(unitType)) return NS_OK;
 313
 314   float pixelsPerUnit = GetPixelsPerUnit(aSVGElement, unitType);
 315   if (pixelsPerUnit == 0.0f) {
 316     return NS_ERROR_ILLEGAL_VALUE;
 317   }
 318
 319   float valueInUserUnits =
 320       mBaseVal * GetPixelsPerUnit(aSVGElement, mSpecifiedUnitType);
 321   float valueInSpecifiedUnits = valueInUserUnits / pixelsPerUnit;
 322
 323   if (!IsFinite(valueInSpecifiedUnits)) {
 324     return NS_ERROR_ILLEGAL_VALUE;
 325   }
 326
 327   // Even though we're not changing the visual effect this length will have
 328   // on the document, we still need to send out notifications in case we have
 329   // mutation listeners, since the actual string value of the attribute will
 330   // change.
 331   AutoChangeLengthNotifier notifier(this, aSVGElement);
 332
 333   mSpecifiedUnitType = uint8_t(unitType);
 334   // Setting aDoSetAttr to false here will ensure we don't call
 335   // Will/DidChangeAngle a second time (and dispatch duplicate notifications).
 336   SetBaseValueInSpecifiedUnits(valueInSpecifiedUnits, aSVGElement, false);
 337
 338   return NS_OK;
 339 }
 340
 341 nsresult SVGAnimatedLength::NewValueSpecifiedUnits(uint16_t aUnitType,
 342                                                    float aValueInSpecifiedUnits,
 343                                                    SVGElement* aSVGElement) {
 344   NS_ENSURE_FINITE(aValueInSpecifiedUnits, NS_ERROR_ILLEGAL_VALUE);
 345
 346   if (!IsValidUnitType(aUnitType)) return NS_ERROR_DOM_NOT_SUPPORTED_ERR;
 347
 348   if (mIsBaseSet && mBaseVal == aValueInSpecifiedUnits &&
 349       mSpecifiedUnitType == uint8_t(aUnitType)) {
 350     return NS_OK;
 351   }
 352
 353   AutoChangeLengthNotifier notifier(this, aSVGElement);
 354
 355   mBaseVal = aValueInSpecifiedUnits;
 356   mIsBaseSet = true;
 357   mSpecifiedUnitType = uint8_t(aUnitType);
 358   if (!mIsAnimated) {
 359     mAnimVal = mBaseVal;
 360   }
 361   return NS_OK;
 362 }
 363
 364 already_AddRefed<DOMSVGLength> SVGAnimatedLength::ToDOMBaseVal(
 365     SVGElement* aSVGElement) {
 366   return DOMSVGLength::GetTearOff(this, aSVGElement, false);
 367 }
 368
 369 already_AddRefed<DOMSVGLength> SVGAnimatedLength::ToDOMAnimVal(
 370     SVGElement* aSVGElement) {
 371   return DOMSVGLength::GetTearOff(this, aSVGElement, true);
 372 }
 373
 374 /* Implementation */
 375
 376 nsresult SVGAnimatedLength::SetBaseValueString(const nsAString& aValueAsString,
 377                                                SVGElement* aSVGElement,
 378                                                bool aDoSetAttr) {
 379   float value;
 380   uint16_t unitType;
 381
 382   if (!GetValueFromString(aValueAsString, value, &unitType)) {
 383     return NS_ERROR_DOM_SYNTAX_ERR;
 384   }
 385
 386   if (mIsBaseSet && mBaseVal == float(value) &&
 387       mSpecifiedUnitType == uint8_t(unitType)) {
 388     return NS_OK;
 389   }
 390
 391   AutoChangeLengthNotifier notifier(this, aSVGElement, aDoSetAttr);
 392
 393   mBaseVal = value;
 394   mIsBaseSet = true;
 395   mSpecifiedUnitType = uint8_t(unitType);
 396   if (!mIsAnimated) {
 397     mAnimVal = mBaseVal;
 398   }
 399
 400   return NS_OK;
 401 }
 402
 403 void SVGAnimatedLength::GetBaseValueString(nsAString& aValueAsString) const {
 404   GetValueString(aValueAsString, mBaseVal, mSpecifiedUnitType);
 405 }
 406
 407 void SVGAnimatedLength::GetAnimValueString(nsAString& aValueAsString) const {
 408   GetValueString(aValueAsString, mAnimVal, mSpecifiedUnitType);
 409 }
 410
 411 nsresult SVGAnimatedLength::SetBaseValue(float aValue, SVGElement* aSVGElement,
 412                                          bool aDoSetAttr) {
 413   float pixelsPerUnit = GetPixelsPerUnit(aSVGElement, mSpecifiedUnitType);
 414   if (pixelsPerUnit == 0.0f) {
 415     return NS_ERROR_ILLEGAL_VALUE;
 416   }
 417
 418   float valueInSpecifiedUnits = aValue / pixelsPerUnit;
 419   if (!IsFinite(valueInSpecifiedUnits)) {
 420     return NS_ERROR_ILLEGAL_VALUE;
 421   }
 422
 423   SetBaseValueInSpecifiedUnits(valueInSpecifiedUnits, aSVGElement, aDoSetAttr);
 424   return NS_OK;
 425 }
 426
 427 void SVGAnimatedLength::SetAnimValueInSpecifiedUnits(float aValue,
 428                                                      SVGElement* aSVGElement) {
 429   if (mAnimVal == aValue && mIsAnimated) {
 430     return;
 431   }
 432   mAnimVal = aValue;
 433   mIsAnimated = true;
 434   aSVGElement->DidAnimateLength(mAttrEnum);
 435 }
 436
 437 nsresult SVGAnimatedLength::SetAnimValue(float aValue,
 438                                          SVGElement* aSVGElement) {
 439   float valueInSpecifiedUnits =
 440       aValue / GetPixelsPerUnit(aSVGElement, mSpecifiedUnitType);
 441
 442   if (IsFinite(valueInSpecifiedUnits)) {
 443     SetAnimValueInSpecifiedUnits(valueInSpecifiedUnits, aSVGElement);
 444     return NS_OK;
 445   }
 446   return NS_ERROR_ILLEGAL_VALUE;
 447 }
 448
 449 already_AddRefed<DOMSVGAnimatedLength> SVGAnimatedLength::ToDOMAnimatedLength(
 450     SVGElement* aSVGElement) {
 451   RefPtr<DOMSVGAnimatedLength> svgAnimatedLength =
 452       sSVGAnimatedLengthTearoffTable.GetTearoff(this);
 453   if (!svgAnimatedLength) {
 454     svgAnimatedLength = new DOMSVGAnimatedLength(this, aSVGElement);
 455     sSVGAnimatedLengthTearoffTable.AddTearoff(this, svgAnimatedLength);
 456   }
 457
 458   return svgAnimatedLength.forget();
 459 }
 460
 461 DOMSVGAnimatedLength::~DOMSVGAnimatedLength() {
 462   sSVGAnimatedLengthTearoffTable.RemoveTearoff(mVal);
 463 }
 464
 465 UniquePtr<SMILAttr> SVGAnimatedLength::ToSMILAttr(SVGElement* aSVGElement) {
 466   return MakeUnique<SMILLength>(this, aSVGElement);
 467 }
 468
 469 nsresult SVGAnimatedLength::SMILLength::ValueFromString(
 470     const nsAString& aStr, const SVGAnimationElement* /*aSrcElement*/,
 471     SMILValue& aValue, bool& aPreventCachingOfSandwich) const {
 472   float value;
 473   uint16_t unitType;
 474
 475   if (!GetValueFromString(aStr, value, &unitType)) {
 476     return NS_ERROR_DOM_SYNTAX_ERR;
 477   }
 478
 479   SMILValue val(SMILFloatType::Singleton());
 480   val.mU.mDouble = value * mVal->GetPixelsPerUnit(mSVGElement, unitType);
 481   aValue = val;
 482   aPreventCachingOfSandwich =
 483       (unitType == SVGLength_Binding::SVG_LENGTHTYPE_PERCENTAGE ||
 484        unitType == SVGLength_Binding::SVG_LENGTHTYPE_EMS ||
 485        unitType == SVGLength_Binding::SVG_LENGTHTYPE_EXS);
 486
 487   return NS_OK;
 488 }
 489
 490 SMILValue SVGAnimatedLength::SMILLength::GetBaseValue() const {
 491   SMILValue val(SMILFloatType::Singleton());
 492   val.mU.mDouble = mVal->GetBaseValue(mSVGElement);
 493   return val;
 494 }
 495
 496 void SVGAnimatedLength::SMILLength::ClearAnimValue() {
 497   if (mVal->mIsAnimated) {
 498     mVal->mIsAnimated = false;
 499     mVal->mAnimVal = mVal->mBaseVal;
 500     mSVGElement->DidAnimateLength(mVal->mAttrEnum);
 501   }
 502 }
 503
 504 nsresult SVGAnimatedLength::SMILLength::SetAnimValue(const SMILValue& aValue) {
 505   NS_ASSERTION(aValue.mType == SMILFloatType::Singleton(),
 506                "Unexpected type to assign animated value");
 507   if (aValue.mType == SMILFloatType::Singleton()) {
 508     return mVal->SetAnimValue(float(aValue.mU.mDouble), mSVGElement);
 509   }
 510   return NS_OK;
 511 }
 512
 513 }  // namespace mozilla