/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* 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 "SVGLengthListSMILType.h" #include "nsSMILValue.h" #include "SVGLengthList.h" #include "nsMathUtils.h" #include "mozilla/FloatingPoint.h" #include #include namespace mozilla { /*static*/ SVGLengthListSMILType SVGLengthListSMILType::sSingleton; //---------------------------------------------------------------------- // nsISMILType implementation void SVGLengthListSMILType::Init(nsSMILValue &aValue) const { MOZ_ASSERT(aValue.IsNull(), "Unexpected value type"); SVGLengthListAndInfo* lengthList = new SVGLengthListAndInfo(); // See the comment documenting Init() in our header file: lengthList->SetCanZeroPadList(true); aValue.mU.mPtr = lengthList; aValue.mType = this; } void SVGLengthListSMILType::Destroy(nsSMILValue& aValue) const { NS_PRECONDITION(aValue.mType == this, "Unexpected SMIL value type"); delete static_cast(aValue.mU.mPtr); aValue.mU.mPtr = nullptr; aValue.mType = nsSMILNullType::Singleton(); } nsresult SVGLengthListSMILType::Assign(nsSMILValue& aDest, const nsSMILValue& aSrc) const { NS_PRECONDITION(aDest.mType == aSrc.mType, "Incompatible SMIL types"); NS_PRECONDITION(aDest.mType == this, "Unexpected SMIL value"); const SVGLengthListAndInfo* src = static_cast(aSrc.mU.mPtr); SVGLengthListAndInfo* dest = static_cast(aDest.mU.mPtr); return dest->CopyFrom(*src); } bool SVGLengthListSMILType::IsEqual(const nsSMILValue& aLeft, const nsSMILValue& aRight) const { NS_PRECONDITION(aLeft.mType == aRight.mType, "Incompatible SMIL types"); NS_PRECONDITION(aLeft.mType == this, "Unexpected type for SMIL value"); return *static_cast(aLeft.mU.mPtr) == *static_cast(aRight.mU.mPtr); } nsresult SVGLengthListSMILType::Add(nsSMILValue& aDest, const nsSMILValue& aValueToAdd, uint32_t aCount) const { NS_PRECONDITION(aDest.mType == this, "Unexpected SMIL type"); NS_PRECONDITION(aValueToAdd.mType == this, "Incompatible SMIL type"); SVGLengthListAndInfo& dest = *static_cast(aDest.mU.mPtr); const SVGLengthListAndInfo& valueToAdd = *static_cast(aValueToAdd.mU.mPtr); // To understand this code, see the comments documenting our Init() method, // and documenting SVGLengthListAndInfo::CanZeroPadList(). // Note that *this* method actually may safely zero pad a shorter list // regardless of the value returned by CanZeroPadList() for that list, // just so long as the shorter list is being added *to* the longer list // and *not* vice versa! It's okay in the case of adding a shorter list to a // longer list because during the add operation we'll end up adding the // zeros to actual specified values. It's *not* okay in the case of adding a // longer list to a shorter list because then we end up adding to implicit // zeros when we'd actually need to add to whatever the underlying values // should be, not zeros, and those values are not explicit or otherwise // available. if (valueToAdd.IsIdentity()) { // Adding identity value - no-op return NS_OK; } if (dest.IsIdentity()) { // Adding *to* an identity value if (!dest.SetLength(valueToAdd.Length())) { return NS_ERROR_OUT_OF_MEMORY; } for (uint32_t i = 0; i < dest.Length(); ++i) { dest[i].SetValueAndUnit(valueToAdd[i].GetValueInCurrentUnits() * aCount, valueToAdd[i].GetUnit()); } dest.SetInfo(valueToAdd.Element(), valueToAdd.Axis(), valueToAdd.CanZeroPadList()); // propagate target element info! return NS_OK; } MOZ_ASSERT(dest.Element() == valueToAdd.Element(), "adding values from different elements...?"); // Zero-pad our |dest| list, if necessary. if (dest.Length() < valueToAdd.Length()) { if (!dest.CanZeroPadList()) { // SVGContentUtils::ReportToConsole return NS_ERROR_FAILURE; } MOZ_ASSERT(valueToAdd.CanZeroPadList(), "values disagree about attribute's zero-paddibility"); uint32_t i = dest.Length(); if (!dest.SetLength(valueToAdd.Length())) { return NS_ERROR_OUT_OF_MEMORY; } for (; i < valueToAdd.Length(); ++i) { dest[i].SetValueAndUnit(0.0f, valueToAdd[i].GetUnit()); } } for (uint32_t i = 0; i < valueToAdd.Length(); ++i) { float valToAdd; if (dest[i].GetUnit() == valueToAdd[i].GetUnit()) { valToAdd = valueToAdd[i].GetValueInCurrentUnits(); } else { // If units differ, we use the unit of the item in 'dest'. // We leave it to the frame code to check that values are finite. valToAdd = valueToAdd[i].GetValueInSpecifiedUnit(dest[i].GetUnit(), dest.Element(), dest.Axis()); } dest[i].SetValueAndUnit( dest[i].GetValueInCurrentUnits() + valToAdd * aCount, dest[i].GetUnit()); } // propagate target element info! dest.SetInfo(valueToAdd.Element(), valueToAdd.Axis(), dest.CanZeroPadList() && valueToAdd.CanZeroPadList()); return NS_OK; } nsresult SVGLengthListSMILType::ComputeDistance(const nsSMILValue& aFrom, const nsSMILValue& aTo, double& aDistance) const { NS_PRECONDITION(aFrom.mType == this, "Unexpected SMIL type"); NS_PRECONDITION(aTo.mType == this, "Incompatible SMIL type"); const SVGLengthListAndInfo& from = *static_cast(aFrom.mU.mPtr); const SVGLengthListAndInfo& to = *static_cast(aTo.mU.mPtr); // To understand this code, see the comments documenting our Init() method, // and documenting SVGLengthListAndInfo::CanZeroPadList(). NS_ASSERTION((from.CanZeroPadList() == to.CanZeroPadList()) || (from.CanZeroPadList() && from.IsEmpty()) || (to.CanZeroPadList() && to.IsEmpty()), "Only \"zero\" nsSMILValues from the SMIL engine should " "return true for CanZeroPadList() when the attribute " "being animated can't be zero padded"); if ((from.Length() < to.Length() && !from.CanZeroPadList()) || (to.Length() < from.Length() && !to.CanZeroPadList())) { // SVGContentUtils::ReportToConsole return NS_ERROR_FAILURE; } // We return the root of the sum of the squares of the deltas between the // user unit values of the lengths at each correspanding index. In the // general case, paced animation is probably not useful, but this strategy at // least does the right thing for paced animation in the face of simple // 'values' lists such as: // // values="100 200 300; 101 201 301; 110 210 310" // // I.e. half way through the simple duration we'll get "105 205 305". double total = 0.0; uint32_t i = 0; for (; i < from.Length() && i < to.Length(); ++i) { double f = from[i].GetValueInUserUnits(from.Element(), from.Axis()); double t = to[i].GetValueInUserUnits(to.Element(), to.Axis()); double delta = t - f; total += delta * delta; } // In the case that from.Length() != to.Length(), one of the following loops // will run. (OK since CanZeroPadList()==true for the other list.) for (; i < from.Length(); ++i) { double f = from[i].GetValueInUserUnits(from.Element(), from.Axis()); total += f * f; } for (; i < to.Length(); ++i) { double t = to[i].GetValueInUserUnits(to.Element(), to.Axis()); total += t * t; } float distance = sqrt(total); if (!IsFinite(distance)) { return NS_ERROR_FAILURE; } aDistance = distance; return NS_OK; } nsresult SVGLengthListSMILType::Interpolate(const nsSMILValue& aStartVal, const nsSMILValue& aEndVal, double aUnitDistance, nsSMILValue& aResult) const { NS_PRECONDITION(aStartVal.mType == aEndVal.mType, "Trying to interpolate different types"); NS_PRECONDITION(aStartVal.mType == this, "Unexpected types for interpolation"); NS_PRECONDITION(aResult.mType == this, "Unexpected result type"); const SVGLengthListAndInfo& start = *static_cast(aStartVal.mU.mPtr); const SVGLengthListAndInfo& end = *static_cast(aEndVal.mU.mPtr); SVGLengthListAndInfo& result = *static_cast(aResult.mU.mPtr); // To understand this code, see the comments documenting our Init() method, // and documenting SVGLengthListAndInfo::CanZeroPadList(). NS_ASSERTION((start.CanZeroPadList() == end.CanZeroPadList()) || (start.CanZeroPadList() && start.IsEmpty()) || (end.CanZeroPadList() && end.IsEmpty()), "Only \"zero\" nsSMILValues from the SMIL engine should " "return true for CanZeroPadList() when the attribute " "being animated can't be zero padded"); if ((start.Length() < end.Length() && !start.CanZeroPadList()) || (end.Length() < start.Length() && !end.CanZeroPadList())) { // SVGContentUtils::ReportToConsole return NS_ERROR_FAILURE; } if (!result.SetLength(std::max(start.Length(), end.Length()))) { return NS_ERROR_OUT_OF_MEMORY; } uint32_t i = 0; for (; i < start.Length() && i < end.Length(); ++i) { float s; if (start[i].GetUnit() == end[i].GetUnit()) { s = start[i].GetValueInCurrentUnits(); } else { // If units differ, we use the unit of the item in 'end'. // We leave it to the frame code to check that values are finite. s = start[i].GetValueInSpecifiedUnit(end[i].GetUnit(), end.Element(), end.Axis()); } float e = end[i].GetValueInCurrentUnits(); result[i].SetValueAndUnit(s + (e - s) * aUnitDistance, end[i].GetUnit()); } // In the case that start.Length() != end.Length(), one of the following // loops will run. (Okay, since CanZeroPadList()==true for the other list.) for (; i < start.Length(); ++i) { result[i].SetValueAndUnit(start[i].GetValueInCurrentUnits() - start[i].GetValueInCurrentUnits() * aUnitDistance, start[i].GetUnit()); } for (; i < end.Length(); ++i) { result[i].SetValueAndUnit(end[i].GetValueInCurrentUnits() * aUnitDistance, end[i].GetUnit()); } // propagate target element info! result.SetInfo(end.Element(), end.Axis(), start.CanZeroPadList() && end.CanZeroPadList()); return NS_OK; } } // namespace mozilla