1 files changed, 360 insertions, 0 deletions
diff --git a/dom/svg/nsSVGViewBox.cpp b/dom/svg/nsSVGViewBox.cpp
new file mode 100644
index 000000000..f0e6b0092
--- /dev/null
+++ b/dom/svg/nsSVGViewBox.cpp
@@ -0,0 +1,360 @@
+/* -*- 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/. */
+
+#include "nsSVGViewBox.h"
+
+#include "mozilla/Move.h"
+#include "nsCharSeparatedTokenizer.h"
+#include "nsSMILValue.h"
+#include "nsTextFormatter.h"
+#include "SVGContentUtils.h"
+#include "SVGViewBoxSMILType.h"
+
+#define NUM_VIEWBOX_COMPONENTS 4
+using namespace mozilla;
+
+/* Implementation of nsSVGViewBoxRect methods */
+
+bool
+nsSVGViewBoxRect::operator==(const nsSVGViewBoxRect& aOther) const
+{
+  if (&aOther == this)
+    return true;
+
+  return (none && aOther.none) ||
+    (!none && !aOther.none &&
+     x == aOther.x &&
+     y == aOther.y &&
+     width == aOther.width &&
+     height == aOther.height);
+}
+
+/* Cycle collection macros for nsSVGViewBox */
+
+NS_SVG_VAL_IMPL_CYCLE_COLLECTION_WRAPPERCACHED(nsSVGViewBox::DOMBaseVal, mSVGElement)
+NS_SVG_VAL_IMPL_CYCLE_COLLECTION_WRAPPERCACHED(nsSVGViewBox::DOMAnimVal, mSVGElement)
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(nsSVGViewBox::DOMBaseVal)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(nsSVGViewBox::DOMBaseVal)
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(nsSVGViewBox::DOMAnimVal)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(nsSVGViewBox::DOMAnimVal)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsSVGViewBox::DOMBaseVal)
+  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsSVGViewBox::DOMAnimVal)
+  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+static nsSVGAttrTearoffTable<nsSVGViewBox, nsSVGViewBox::DOMBaseVal>
+  sBaseSVGViewBoxTearoffTable;
+static nsSVGAttrTearoffTable<nsSVGViewBox, nsSVGViewBox::DOMAnimVal>
+  sAnimSVGViewBoxTearoffTable;
+nsSVGAttrTearoffTable<nsSVGViewBox, dom::SVGAnimatedRect>
+  nsSVGViewBox::sSVGAnimatedRectTearoffTable;
+
+
+/* Implementation of nsSVGViewBox methods */
+
+void
+nsSVGViewBox::Init()
+{
+  mHasBaseVal = false;
+  // We shouldn't use mBaseVal for rendering (its usages should be guarded with
+  // "mHasBaseVal" checks), but just in case we do by accident, this will
+  // ensure that we treat it as "none" and ignore its numeric values:
+  mBaseVal.none = true;
+
+  mAnimVal = nullptr;
+}
+
+bool
+nsSVGViewBox::HasRect() const
+{
+  // Check mAnimVal if we have one; otherwise, check mBaseVal if we have one;
+  // otherwise, just return false (we clearly do not have a rect).
+  const nsSVGViewBoxRect* rect = mAnimVal;
+  if (!rect) {
+    if (!mHasBaseVal) {
+      // no anim val, no base val --> no viewbox rect
+      return false;
+    }
+    rect = &mBaseVal;
+  }
+
+  return !rect->none && rect->width >= 0 && rect->height >= 0;
+}
+
+void
+nsSVGViewBox::SetAnimValue(const nsSVGViewBoxRect& aRect,
+                           nsSVGElement *aSVGElement)
+{
+  if (!mAnimVal) {
+    // it's okay if allocation fails - and no point in reporting that
+    mAnimVal = new nsSVGViewBoxRect(aRect);
+  } else {
+    if (aRect == *mAnimVal) {
+      return;
+    }
+    *mAnimVal = aRect;
+  }
+  aSVGElement->DidAnimateViewBox();
+}
+
+void
+nsSVGViewBox::SetBaseValue(const nsSVGViewBoxRect& aRect,
+                           nsSVGElement *aSVGElement)
+{
+  if (!mHasBaseVal || mBaseVal == aRect) {
+    // This method is used to set a single x, y, width
+    // or height value. It can't create a base value
+    // as the other components may be undefined. We record
+    // the new value though, so as not to lose data.
+    mBaseVal = aRect;
+    return;
+  }
+
+  nsAttrValue emptyOrOldValue = aSVGElement->WillChangeViewBox();
+
+  mBaseVal = aRect;
+  mHasBaseVal = true;
+
+  aSVGElement->DidChangeViewBox(emptyOrOldValue);
+  if (mAnimVal) {
+    aSVGElement->AnimationNeedsResample();
+  }
+}
+
+static nsresult
+ToSVGViewBoxRect(const nsAString& aStr, nsSVGViewBoxRect *aViewBox)
+{
+  if (aStr.EqualsLiteral("none")) {
+    aViewBox->none = true;
+    return NS_OK;
+  }
+
+  nsCharSeparatedTokenizerTemplate<IsSVGWhitespace>
+    tokenizer(aStr, ',',
+              nsCharSeparatedTokenizer::SEPARATOR_OPTIONAL);
+  float vals[NUM_VIEWBOX_COMPONENTS];
+  uint32_t i;
+  for (i = 0; i < NUM_VIEWBOX_COMPONENTS && tokenizer.hasMoreTokens(); ++i) {
+    if (!SVGContentUtils::ParseNumber(tokenizer.nextToken(), vals[i])) {
+      return NS_ERROR_DOM_SYNTAX_ERR;
+    }
+  }
+
+  if (i != NUM_VIEWBOX_COMPONENTS ||              // Too few values.
+      tokenizer.hasMoreTokens() ||                // Too many values.
+      tokenizer.separatorAfterCurrentToken()) {   // Trailing comma.
+    return NS_ERROR_DOM_SYNTAX_ERR;
+  }
+
+  aViewBox->x = vals[0];
+  aViewBox->y = vals[1];
+  aViewBox->width = vals[2];
+  aViewBox->height = vals[3];
+  aViewBox->none = false;
+
+  return NS_OK;
+}
+
+nsresult
+nsSVGViewBox::SetBaseValueString(const nsAString& aValue,
+                                 nsSVGElement *aSVGElement,
+                                 bool aDoSetAttr)
+{
+  nsSVGViewBoxRect viewBox;
+
+  nsresult rv = ToSVGViewBoxRect(aValue, &viewBox);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+  // Comparison against mBaseVal is only valid if we currently have a base val.
+  if (mHasBaseVal && viewBox == mBaseVal) {
+    return NS_OK;
+  }
+
+  nsAttrValue emptyOrOldValue;
+  if (aDoSetAttr) {
+    emptyOrOldValue = aSVGElement->WillChangeViewBox();
+  }
+  mHasBaseVal = true;
+  mBaseVal = viewBox;
+
+  if (aDoSetAttr) {
+    aSVGElement->DidChangeViewBox(emptyOrOldValue);
+  }
+  if (mAnimVal) {
+    aSVGElement->AnimationNeedsResample();
+  }
+  return NS_OK;
+}
+
+void
+nsSVGViewBox::GetBaseValueString(nsAString& aValue) const
+{
+  if (mBaseVal.none) {
+    aValue.AssignLiteral("none");
+    return;
+  }
+  char16_t buf[200];
+  nsTextFormatter::snprintf(buf, sizeof(buf)/sizeof(char16_t),
+                            u"%g %g %g %g",
+                            (double)mBaseVal.x, (double)mBaseVal.y,
+                            (double)mBaseVal.width, (double)mBaseVal.height);
+  aValue.Assign(buf);
+}
+
+
+already_AddRefed<dom::SVGAnimatedRect>
+nsSVGViewBox::ToSVGAnimatedRect(nsSVGElement* aSVGElement)
+{
+  RefPtr<dom::SVGAnimatedRect> domAnimatedRect =
+    sSVGAnimatedRectTearoffTable.GetTearoff(this);
+  if (!domAnimatedRect) {
+    domAnimatedRect = new dom::SVGAnimatedRect(this, aSVGElement);
+    sSVGAnimatedRectTearoffTable.AddTearoff(this, domAnimatedRect);
+  }
+
+  return domAnimatedRect.forget();
+}
+
+already_AddRefed<dom::SVGIRect>
+nsSVGViewBox::ToDOMBaseVal(nsSVGElement *aSVGElement)
+{
+  if (!mHasBaseVal || mBaseVal.none) {
+    return nullptr;
+  }
+
+  RefPtr<DOMBaseVal> domBaseVal =
+    sBaseSVGViewBoxTearoffTable.GetTearoff(this);
+  if (!domBaseVal) {
+    domBaseVal = new DOMBaseVal(this, aSVGElement);
+    sBaseSVGViewBoxTearoffTable.AddTearoff(this, domBaseVal);
+  }
+
+ return domBaseVal.forget();
+}
+
+nsSVGViewBox::DOMBaseVal::~DOMBaseVal()
+{
+  sBaseSVGViewBoxTearoffTable.RemoveTearoff(mVal);
+}
+
+already_AddRefed<dom::SVGIRect>
+nsSVGViewBox::ToDOMAnimVal(nsSVGElement *aSVGElement)
+{
+  if ((mAnimVal && mAnimVal->none) ||
+      (!mAnimVal && (!mHasBaseVal || mBaseVal.none))) {
+    return nullptr;
+  }
+
+  RefPtr<DOMAnimVal> domAnimVal =
+    sAnimSVGViewBoxTearoffTable.GetTearoff(this);
+  if (!domAnimVal) {
+    domAnimVal = new DOMAnimVal(this, aSVGElement);
+    sAnimSVGViewBoxTearoffTable.AddTearoff(this, domAnimVal);
+  }
+
+  return domAnimVal.forget();
+}
+
+nsSVGViewBox::DOMAnimVal::~DOMAnimVal()
+{
+  sAnimSVGViewBoxTearoffTable.RemoveTearoff(mVal);
+}
+
+void
+nsSVGViewBox::DOMBaseVal::SetX(float aX, ErrorResult& aRv)
+{
+  nsSVGViewBoxRect rect = mVal->GetBaseValue();
+  rect.x = aX;
+  mVal->SetBaseValue(rect, mSVGElement);
+}
+
+void
+nsSVGViewBox::DOMBaseVal::SetY(float aY, ErrorResult& aRv)
+{
+  nsSVGViewBoxRect rect = mVal->GetBaseValue();
+  rect.y = aY;
+  mVal->SetBaseValue(rect, mSVGElement);
+}
+
+void
+nsSVGViewBox::DOMBaseVal::SetWidth(float aWidth, ErrorResult& aRv)
+{
+  nsSVGViewBoxRect rect = mVal->GetBaseValue();
+  rect.width = aWidth;
+  mVal->SetBaseValue(rect, mSVGElement);
+}
+
+void
+nsSVGViewBox::DOMBaseVal::SetHeight(float aHeight, ErrorResult& aRv)
+{
+  nsSVGViewBoxRect rect = mVal->GetBaseValue();
+  rect.height = aHeight;
+  mVal->SetBaseValue(rect, mSVGElement);
+}
+
+nsISMILAttr*
+nsSVGViewBox::ToSMILAttr(nsSVGElement *aSVGElement)
+{
+  return new SMILViewBox(this, aSVGElement);
+}
+
+nsresult
+nsSVGViewBox::SMILViewBox
+            ::ValueFromString(const nsAString& aStr,
+                              const dom::SVGAnimationElement* /*aSrcElement*/,
+                              nsSMILValue& aValue,
+                              bool& aPreventCachingOfSandwich) const
+{
+  nsSVGViewBoxRect viewBox;
+  nsresult res = ToSVGViewBoxRect(aStr, &viewBox);
+  if (NS_FAILED(res)) {
+    return res;
+  }
+  nsSMILValue val(&SVGViewBoxSMILType::sSingleton);
+  *static_cast<nsSVGViewBoxRect*>(val.mU.mPtr) = viewBox;
+  aValue = Move(val);
+  aPreventCachingOfSandwich = false;
+  
+  return NS_OK;
+}
+
+nsSMILValue
+nsSVGViewBox::SMILViewBox::GetBaseValue() const
+{
+  nsSMILValue val(&SVGViewBoxSMILType::sSingleton);
+  *static_cast<nsSVGViewBoxRect*>(val.mU.mPtr) = mVal->mBaseVal;
+  return val;
+}
+
+void
+nsSVGViewBox::SMILViewBox::ClearAnimValue()
+{
+  if (mVal->mAnimVal) {
+    mVal->mAnimVal = nullptr;
+    mSVGElement->DidAnimateViewBox();
+  }
+}
+
+nsresult
+nsSVGViewBox::SMILViewBox::SetAnimValue(const nsSMILValue& aValue)
+{
+  NS_ASSERTION(aValue.mType == &SVGViewBoxSMILType::sSingleton,
+               "Unexpected type to assign animated value");
+  if (aValue.mType == &SVGViewBoxSMILType::sSingleton) {
+    nsSVGViewBoxRect &vb = *static_cast<nsSVGViewBoxRect*>(aValue.mU.mPtr);
+    mVal->SetAnimValue(vb, mSVGElement);
+  }
+  return NS_OK;
+}