mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-25 13:51:41 +00:00
361 lines
9.5 KiB
C++
361 lines
9.5 KiB
C++
/* -*- 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),
|
|
MOZ_UTF16("%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;
|
|
}
|