1192 lines
35 KiB
C++
1192 lines
35 KiB
C++
/* -*- 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 <stdint.h>
|
|
#include "mozilla/ArrayUtils.h"
|
|
#include "mozilla/ContentEvents.h"
|
|
#include "mozilla/EventDispatcher.h"
|
|
#include "mozilla/Likely.h"
|
|
|
|
#include "nsGkAtoms.h"
|
|
#include "nsLayoutUtils.h"
|
|
#include "nsLayoutStylesheetCache.h"
|
|
#include "DOMSVGNumber.h"
|
|
#include "DOMSVGLength.h"
|
|
#include "nsSVGAngle.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsIPresShell.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsIDocument.h"
|
|
#include "mozilla/dom/SVGMatrix.h"
|
|
#include "DOMSVGPoint.h"
|
|
#include "nsIFrame.h"
|
|
#include "nsFrameSelection.h"
|
|
#include "nsISVGSVGFrame.h" //XXX
|
|
#include "mozilla/dom/SVGRect.h"
|
|
#include "nsError.h"
|
|
#include "nsISVGChildFrame.h"
|
|
#include "mozilla/dom/SVGSVGElement.h"
|
|
#include "mozilla/dom/SVGSVGElementBinding.h"
|
|
#include "nsSVGUtils.h"
|
|
#include "mozilla/dom/SVGViewElement.h"
|
|
#include "nsStyleUtil.h"
|
|
#include "SVGContentUtils.h"
|
|
|
|
#include "nsSMILTimeContainer.h"
|
|
#include "nsSMILAnimationController.h"
|
|
#include "nsSMILTypes.h"
|
|
#include "SVGAngle.h"
|
|
#include <algorithm>
|
|
#include "prtime.h"
|
|
|
|
NS_IMPL_NS_NEW_NAMESPACED_SVG_ELEMENT_CHECK_PARSER(SVG)
|
|
|
|
using namespace mozilla::gfx;
|
|
|
|
namespace mozilla {
|
|
namespace dom {
|
|
|
|
class SVGAnimatedLength;
|
|
|
|
JSObject*
|
|
SVGSVGElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
|
|
{
|
|
return SVGSVGElementBinding::Wrap(aCx, this, aGivenProto);
|
|
}
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_INHERITED(DOMSVGTranslatePoint, nsISVGPoint,
|
|
mElement)
|
|
|
|
NS_IMPL_ADDREF_INHERITED(DOMSVGTranslatePoint, nsISVGPoint)
|
|
NS_IMPL_RELEASE_INHERITED(DOMSVGTranslatePoint, nsISVGPoint)
|
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DOMSVGTranslatePoint)
|
|
NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
|
|
// We have to qualify nsISVGPoint because NS_GET_IID looks for a class in the
|
|
// global namespace
|
|
NS_INTERFACE_MAP_ENTRY(mozilla::nsISVGPoint)
|
|
NS_INTERFACE_MAP_ENTRY(nsISupports)
|
|
NS_INTERFACE_MAP_END
|
|
|
|
SVGSVGElement::~SVGSVGElement()
|
|
{
|
|
}
|
|
|
|
DOMSVGPoint*
|
|
DOMSVGTranslatePoint::Copy()
|
|
{
|
|
return new DOMSVGPoint(mPt.GetX(), mPt.GetY());
|
|
}
|
|
|
|
nsISupports*
|
|
DOMSVGTranslatePoint::GetParentObject()
|
|
{
|
|
return static_cast<nsIDOMSVGElement*>(mElement);
|
|
}
|
|
|
|
void
|
|
DOMSVGTranslatePoint::SetX(float aValue, ErrorResult& rv)
|
|
{
|
|
mElement->SetCurrentTranslate(aValue, mPt.GetY());
|
|
}
|
|
|
|
void
|
|
DOMSVGTranslatePoint::SetY(float aValue, ErrorResult& rv)
|
|
{
|
|
mElement->SetCurrentTranslate(mPt.GetX(), aValue);
|
|
}
|
|
|
|
already_AddRefed<nsISVGPoint>
|
|
DOMSVGTranslatePoint::MatrixTransform(SVGMatrix& matrix)
|
|
{
|
|
float a = matrix.A(), b = matrix.B(), c = matrix.C();
|
|
float d = matrix.D(), e = matrix.E(), f = matrix.F();
|
|
float x = mPt.GetX();
|
|
float y = mPt.GetY();
|
|
|
|
nsCOMPtr<nsISVGPoint> point = new DOMSVGPoint(a*x + c*y + e, b*x + d*y + f);
|
|
return point.forget();
|
|
}
|
|
|
|
SVGView::SVGView()
|
|
{
|
|
mZoomAndPan.Init(SVGSVGElement::ZOOMANDPAN,
|
|
SVG_ZOOMANDPAN_MAGNIFY);
|
|
mViewBox.Init();
|
|
mPreserveAspectRatio.Init();
|
|
}
|
|
|
|
nsSVGElement::LengthInfo SVGSVGElement::sLengthInfo[4] =
|
|
{
|
|
{ &nsGkAtoms::x, 0, nsIDOMSVGLength::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
|
|
{ &nsGkAtoms::y, 0, nsIDOMSVGLength::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
|
|
{ &nsGkAtoms::width, 100, nsIDOMSVGLength::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::X },
|
|
{ &nsGkAtoms::height, 100, nsIDOMSVGLength::SVG_LENGTHTYPE_PERCENTAGE, SVGContentUtils::Y },
|
|
};
|
|
|
|
nsSVGEnumMapping SVGSVGElement::sZoomAndPanMap[] = {
|
|
{&nsGkAtoms::disable, SVG_ZOOMANDPAN_DISABLE},
|
|
{&nsGkAtoms::magnify, SVG_ZOOMANDPAN_MAGNIFY},
|
|
{nullptr, 0}
|
|
};
|
|
|
|
nsSVGElement::EnumInfo SVGSVGElement::sEnumInfo[1] =
|
|
{
|
|
{ &nsGkAtoms::zoomAndPan,
|
|
sZoomAndPanMap,
|
|
SVG_ZOOMANDPAN_MAGNIFY
|
|
}
|
|
};
|
|
|
|
//----------------------------------------------------------------------
|
|
// nsISupports methods
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(SVGSVGElement)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(SVGSVGElement,
|
|
SVGSVGElementBase)
|
|
if (tmp->mTimedDocumentRoot) {
|
|
tmp->mTimedDocumentRoot->Unlink();
|
|
}
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(SVGSVGElement,
|
|
SVGSVGElementBase)
|
|
if (tmp->mTimedDocumentRoot) {
|
|
tmp->mTimedDocumentRoot->Traverse(&cb);
|
|
}
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
|
|
NS_IMPL_ADDREF_INHERITED(SVGSVGElement,SVGSVGElementBase)
|
|
NS_IMPL_RELEASE_INHERITED(SVGSVGElement,SVGSVGElementBase)
|
|
|
|
NS_INTERFACE_TABLE_HEAD_CYCLE_COLLECTION_INHERITED(SVGSVGElement)
|
|
NS_INTERFACE_TABLE_INHERITED(SVGSVGElement, nsIDOMNode, nsIDOMElement,
|
|
nsIDOMSVGElement)
|
|
NS_INTERFACE_TABLE_TAIL_INHERITING(SVGSVGElementBase)
|
|
|
|
//----------------------------------------------------------------------
|
|
// Implementation
|
|
|
|
SVGSVGElement::SVGSVGElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo,
|
|
FromParser aFromParser)
|
|
: SVGSVGElementBase(aNodeInfo),
|
|
mViewportWidth(0),
|
|
mViewportHeight(0),
|
|
mCurrentTranslate(0.0f, 0.0f),
|
|
mCurrentScale(1.0f),
|
|
mPreviousTranslate(0.0f, 0.0f),
|
|
mPreviousScale(1.0f),
|
|
mStartAnimationOnBindToTree(aFromParser == NOT_FROM_PARSER ||
|
|
aFromParser == FROM_PARSER_FRAGMENT ||
|
|
aFromParser == FROM_PARSER_XSLT),
|
|
mImageNeedsTransformInvalidation(false),
|
|
mIsPaintingSVGImageElement(false),
|
|
mHasChildrenOnlyTransform(false)
|
|
{
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// nsIDOMNode methods
|
|
|
|
// From NS_IMPL_ELEMENT_CLONE_WITH_INIT(SVGSVGElement)
|
|
nsresult
|
|
SVGSVGElement::Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult) const
|
|
{
|
|
*aResult = nullptr;
|
|
already_AddRefed<mozilla::dom::NodeInfo> ni = RefPtr<mozilla::dom::NodeInfo>(aNodeInfo).forget();
|
|
SVGSVGElement *it = new SVGSVGElement(ni, NOT_FROM_PARSER);
|
|
|
|
nsCOMPtr<nsINode> kungFuDeathGrip = it;
|
|
nsresult rv1 = it->Init();
|
|
nsresult rv2 = const_cast<SVGSVGElement*>(this)->CopyInnerTo(it);
|
|
if (NS_SUCCEEDED(rv1) && NS_SUCCEEDED(rv2)) {
|
|
kungFuDeathGrip.swap(*aResult);
|
|
}
|
|
|
|
return NS_FAILED(rv1) ? rv1 : rv2;
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
// nsIDOMSVGSVGElement methods:
|
|
|
|
already_AddRefed<SVGAnimatedLength>
|
|
SVGSVGElement::X()
|
|
{
|
|
return mLengthAttributes[ATTR_X].ToDOMAnimatedLength(this);
|
|
}
|
|
|
|
already_AddRefed<SVGAnimatedLength>
|
|
SVGSVGElement::Y()
|
|
{
|
|
return mLengthAttributes[ATTR_Y].ToDOMAnimatedLength(this);
|
|
}
|
|
|
|
already_AddRefed<SVGAnimatedLength>
|
|
SVGSVGElement::Width()
|
|
{
|
|
return mLengthAttributes[ATTR_WIDTH].ToDOMAnimatedLength(this);
|
|
}
|
|
|
|
already_AddRefed<SVGAnimatedLength>
|
|
SVGSVGElement::Height()
|
|
{
|
|
return mLengthAttributes[ATTR_HEIGHT].ToDOMAnimatedLength(this);
|
|
}
|
|
|
|
float
|
|
SVGSVGElement::PixelUnitToMillimeterX()
|
|
{
|
|
return MM_PER_INCH_FLOAT / 96;
|
|
}
|
|
|
|
float
|
|
SVGSVGElement::PixelUnitToMillimeterY()
|
|
{
|
|
return PixelUnitToMillimeterX();
|
|
}
|
|
|
|
float
|
|
SVGSVGElement::ScreenPixelToMillimeterX()
|
|
{
|
|
return MM_PER_INCH_FLOAT / 96;
|
|
}
|
|
|
|
float
|
|
SVGSVGElement::ScreenPixelToMillimeterY()
|
|
{
|
|
return ScreenPixelToMillimeterX();
|
|
}
|
|
|
|
bool
|
|
SVGSVGElement::UseCurrentView()
|
|
{
|
|
return mSVGView || mCurrentViewID;
|
|
}
|
|
|
|
float
|
|
SVGSVGElement::CurrentScale()
|
|
{
|
|
return mCurrentScale;
|
|
}
|
|
|
|
#define CURRENT_SCALE_MAX 16.0f
|
|
#define CURRENT_SCALE_MIN 0.0625f
|
|
|
|
void
|
|
SVGSVGElement::SetCurrentScale(float aCurrentScale)
|
|
{
|
|
SetCurrentScaleTranslate(aCurrentScale,
|
|
mCurrentTranslate.GetX(), mCurrentTranslate.GetY());
|
|
}
|
|
|
|
already_AddRefed<nsISVGPoint>
|
|
SVGSVGElement::CurrentTranslate()
|
|
{
|
|
nsCOMPtr<nsISVGPoint> point = new DOMSVGTranslatePoint(&mCurrentTranslate, this);
|
|
return point.forget();
|
|
}
|
|
|
|
uint32_t
|
|
SVGSVGElement::SuspendRedraw(uint32_t max_wait_milliseconds)
|
|
{
|
|
// suspendRedraw is a no-op in Mozilla, so it doesn't matter what
|
|
// we return
|
|
return 1;
|
|
}
|
|
|
|
void
|
|
SVGSVGElement::UnsuspendRedraw(uint32_t suspend_handle_id)
|
|
{
|
|
// no-op
|
|
}
|
|
|
|
void
|
|
SVGSVGElement::UnsuspendRedrawAll()
|
|
{
|
|
// no-op
|
|
}
|
|
|
|
void
|
|
SVGSVGElement::ForceRedraw()
|
|
{
|
|
// no-op
|
|
}
|
|
|
|
void
|
|
SVGSVGElement::PauseAnimations()
|
|
{
|
|
if (mTimedDocumentRoot) {
|
|
mTimedDocumentRoot->Pause(nsSMILTimeContainer::PAUSE_SCRIPT);
|
|
}
|
|
// else we're not the outermost <svg> or not bound to a tree, so silently fail
|
|
}
|
|
|
|
void
|
|
SVGSVGElement::UnpauseAnimations()
|
|
{
|
|
if (mTimedDocumentRoot) {
|
|
mTimedDocumentRoot->Resume(nsSMILTimeContainer::PAUSE_SCRIPT);
|
|
}
|
|
// else we're not the outermost <svg> or not bound to a tree, so silently fail
|
|
}
|
|
|
|
bool
|
|
SVGSVGElement::AnimationsPaused()
|
|
{
|
|
nsSMILTimeContainer* root = GetTimedDocumentRoot();
|
|
return root && root->IsPausedByType(nsSMILTimeContainer::PAUSE_SCRIPT);
|
|
}
|
|
|
|
float
|
|
SVGSVGElement::GetCurrentTime()
|
|
{
|
|
nsSMILTimeContainer* root = GetTimedDocumentRoot();
|
|
if (root) {
|
|
double fCurrentTimeMs = double(root->GetCurrentTime());
|
|
return (float)(fCurrentTimeMs / PR_MSEC_PER_SEC);
|
|
} else {
|
|
return 0.f;
|
|
}
|
|
}
|
|
|
|
void
|
|
SVGSVGElement::SetCurrentTime(float seconds)
|
|
{
|
|
if (mTimedDocumentRoot) {
|
|
// Make sure the timegraph is up-to-date
|
|
FlushAnimations();
|
|
double fMilliseconds = double(seconds) * PR_MSEC_PER_SEC;
|
|
// Round to nearest whole number before converting, to avoid precision
|
|
// errors
|
|
nsSMILTime lMilliseconds = int64_t(NS_round(fMilliseconds));
|
|
mTimedDocumentRoot->SetCurrentTime(lMilliseconds);
|
|
AnimationNeedsResample();
|
|
// Trigger synchronous sample now, to:
|
|
// - Make sure we get an up-to-date paint after this method
|
|
// - re-enable event firing (it got disabled during seeking, and it
|
|
// doesn't get re-enabled until the first sample after the seek -- so
|
|
// let's make that happen now.)
|
|
FlushAnimations();
|
|
}
|
|
// else we're not the outermost <svg> or not bound to a tree, so silently fail
|
|
}
|
|
|
|
void
|
|
SVGSVGElement::DeselectAll()
|
|
{
|
|
nsIFrame* frame = GetPrimaryFrame();
|
|
if (frame) {
|
|
RefPtr<nsFrameSelection> frameSelection = frame->GetFrameSelection();
|
|
frameSelection->ClearNormalSelection();
|
|
}
|
|
}
|
|
|
|
already_AddRefed<DOMSVGNumber>
|
|
SVGSVGElement::CreateSVGNumber()
|
|
{
|
|
RefPtr<DOMSVGNumber> number = new DOMSVGNumber(ToSupports(this));
|
|
return number.forget();
|
|
}
|
|
|
|
already_AddRefed<DOMSVGLength>
|
|
SVGSVGElement::CreateSVGLength()
|
|
{
|
|
nsCOMPtr<DOMSVGLength> length = new DOMSVGLength();
|
|
return length.forget();
|
|
}
|
|
|
|
already_AddRefed<SVGAngle>
|
|
SVGSVGElement::CreateSVGAngle()
|
|
{
|
|
nsSVGAngle* angle = new nsSVGAngle();
|
|
angle->Init();
|
|
RefPtr<SVGAngle> svgangle = new SVGAngle(angle, this, SVGAngle::CreatedValue);
|
|
return svgangle.forget();
|
|
}
|
|
|
|
already_AddRefed<nsISVGPoint>
|
|
SVGSVGElement::CreateSVGPoint()
|
|
{
|
|
nsCOMPtr<nsISVGPoint> point = new DOMSVGPoint(0, 0);
|
|
return point.forget();
|
|
}
|
|
|
|
already_AddRefed<SVGMatrix>
|
|
SVGSVGElement::CreateSVGMatrix()
|
|
{
|
|
RefPtr<SVGMatrix> matrix = new SVGMatrix();
|
|
return matrix.forget();
|
|
}
|
|
|
|
already_AddRefed<SVGIRect>
|
|
SVGSVGElement::CreateSVGRect()
|
|
{
|
|
return NS_NewSVGRect(this);
|
|
}
|
|
|
|
already_AddRefed<SVGTransform>
|
|
SVGSVGElement::CreateSVGTransform()
|
|
{
|
|
RefPtr<SVGTransform> transform = new SVGTransform();
|
|
return transform.forget();
|
|
}
|
|
|
|
already_AddRefed<SVGTransform>
|
|
SVGSVGElement::CreateSVGTransformFromMatrix(SVGMatrix& matrix)
|
|
{
|
|
RefPtr<SVGTransform> transform = new SVGTransform(matrix.GetMatrix());
|
|
return transform.forget();
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
already_AddRefed<SVGAnimatedRect>
|
|
SVGSVGElement::ViewBox()
|
|
{
|
|
return mViewBox.ToSVGAnimatedRect(this);
|
|
}
|
|
|
|
already_AddRefed<DOMSVGAnimatedPreserveAspectRatio>
|
|
SVGSVGElement::PreserveAspectRatio()
|
|
{
|
|
return mPreserveAspectRatio.ToDOMAnimatedPreserveAspectRatio(this);
|
|
}
|
|
|
|
uint16_t
|
|
SVGSVGElement::ZoomAndPan()
|
|
{
|
|
return mEnumAttributes[ZOOMANDPAN].GetAnimValue();
|
|
}
|
|
|
|
void
|
|
SVGSVGElement::SetZoomAndPan(uint16_t aZoomAndPan, ErrorResult& rv)
|
|
{
|
|
if (aZoomAndPan == SVG_ZOOMANDPAN_DISABLE ||
|
|
aZoomAndPan == SVG_ZOOMANDPAN_MAGNIFY) {
|
|
mEnumAttributes[ZOOMANDPAN].SetBaseValue(aZoomAndPan, this);
|
|
return;
|
|
}
|
|
|
|
rv.ThrowRangeError<MSG_INVALID_ZOOMANDPAN_VALUE_ERROR>();
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// helper methods for implementing SVGZoomEvent:
|
|
|
|
void
|
|
SVGSVGElement::SetCurrentScaleTranslate(float s, float x, float y)
|
|
{
|
|
if (s == mCurrentScale &&
|
|
x == mCurrentTranslate.GetX() && y == mCurrentTranslate.GetY()) {
|
|
return;
|
|
}
|
|
|
|
// Prevent bizarre behaviour and maxing out of CPU and memory by clamping
|
|
if (s < CURRENT_SCALE_MIN)
|
|
s = CURRENT_SCALE_MIN;
|
|
else if (s > CURRENT_SCALE_MAX)
|
|
s = CURRENT_SCALE_MAX;
|
|
|
|
// IMPORTANT: If either mCurrentTranslate *or* mCurrentScale is changed then
|
|
// mPreviousTranslate_x, mPreviousTranslate_y *and* mPreviousScale must all
|
|
// be updated otherwise SVGZoomEvents will end up with invalid data. I.e. an
|
|
// SVGZoomEvent's properties previousScale and previousTranslate must contain
|
|
// the state of currentScale and currentTranslate immediately before the
|
|
// change that caused the event's dispatch, which is *not* necessarily the
|
|
// same thing as the values of currentScale and currentTranslate prior to
|
|
// their own last change.
|
|
mPreviousScale = mCurrentScale;
|
|
mPreviousTranslate = mCurrentTranslate;
|
|
|
|
mCurrentScale = s;
|
|
mCurrentTranslate = SVGPoint(x, y);
|
|
|
|
// now dispatch the appropriate event if we are the root element
|
|
nsIDocument* doc = GetUncomposedDoc();
|
|
if (doc) {
|
|
nsCOMPtr<nsIPresShell> presShell = doc->GetShell();
|
|
if (presShell && IsRoot()) {
|
|
nsEventStatus status = nsEventStatus_eIgnore;
|
|
if (mPreviousScale != mCurrentScale) {
|
|
InternalSVGZoomEvent svgZoomEvent(true, eSVGZoom);
|
|
presShell->HandleDOMEventWithTarget(this, &svgZoomEvent, &status);
|
|
} else {
|
|
WidgetEvent svgScrollEvent(true, eSVGScroll);
|
|
presShell->HandleDOMEventWithTarget(this, &svgScrollEvent, &status);
|
|
}
|
|
InvalidateTransformNotifyFrame();
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
SVGSVGElement::SetCurrentTranslate(float x, float y)
|
|
{
|
|
SetCurrentScaleTranslate(mCurrentScale, x, y);
|
|
}
|
|
|
|
nsSMILTimeContainer*
|
|
SVGSVGElement::GetTimedDocumentRoot()
|
|
{
|
|
if (mTimedDocumentRoot) {
|
|
return mTimedDocumentRoot;
|
|
}
|
|
|
|
// We must not be the outermost <svg> element, try to find it
|
|
SVGSVGElement *outerSVGElement =
|
|
SVGContentUtils::GetOuterSVGElement(this);
|
|
|
|
if (outerSVGElement) {
|
|
return outerSVGElement->GetTimedDocumentRoot();
|
|
}
|
|
// invalid structure
|
|
return nullptr;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// nsIContent methods
|
|
|
|
NS_IMETHODIMP_(bool)
|
|
SVGSVGElement::IsAttributeMapped(const nsIAtom* name) const
|
|
{
|
|
// We want to map the 'width' and 'height' attributes into style for
|
|
// outer-<svg>, except when the attributes aren't set (since their default
|
|
// values of '100%' can cause unexpected and undesirable behaviour for SVG
|
|
// inline in HTML). We rely on nsSVGElement::UpdateContentStyleRule() to
|
|
// prevent mapping of the default values into style (it only maps attributes
|
|
// that are set). We also rely on a check in nsSVGElement::
|
|
// UpdateContentStyleRule() to prevent us mapping the attributes when they're
|
|
// given a <length> value that is not currently recognized by the SVG
|
|
// specification.
|
|
|
|
if (!IsInner() && (name == nsGkAtoms::width || name == nsGkAtoms::height)) {
|
|
return true;
|
|
}
|
|
|
|
static const MappedAttributeEntry* const map[] = {
|
|
sColorMap,
|
|
sFEFloodMap,
|
|
sFillStrokeMap,
|
|
sFiltersMap,
|
|
sFontSpecificationMap,
|
|
sGradientStopMap,
|
|
sGraphicsMap,
|
|
sLightingEffectsMap,
|
|
sMarkersMap,
|
|
sTextContentElementsMap,
|
|
sViewportsMap
|
|
};
|
|
|
|
return FindAttributeDependence(name, map) ||
|
|
SVGSVGElementBase::IsAttributeMapped(name);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// nsIContent methods:
|
|
|
|
nsresult
|
|
SVGSVGElement::GetEventTargetParent(EventChainPreVisitor& aVisitor)
|
|
{
|
|
if (aVisitor.mEvent->mMessage == eSVGLoad) {
|
|
if (mTimedDocumentRoot) {
|
|
mTimedDocumentRoot->Begin();
|
|
// Set 'resample needed' flag, so that if any script calls a DOM method
|
|
// that requires up-to-date animations before our first sample callback,
|
|
// we'll force a synchronous sample.
|
|
AnimationNeedsResample();
|
|
}
|
|
}
|
|
return SVGSVGElementBase::GetEventTargetParent(aVisitor);
|
|
}
|
|
|
|
bool
|
|
SVGSVGElement::IsEventAttributeName(nsIAtom* aName)
|
|
{
|
|
/* The events in EventNameType_SVGSVG are for events that are only
|
|
applicable to outermost 'svg' elements. We don't check if we're an outer
|
|
'svg' element in case we're not inserted into the document yet, but since
|
|
the target of the events in question will always be the outermost 'svg'
|
|
element, this shouldn't cause any real problems.
|
|
*/
|
|
return nsContentUtils::IsEventAttributeName(aName,
|
|
(EventNameType_SVGGraphic | EventNameType_SVGSVG));
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// nsSVGElement overrides
|
|
|
|
// Helper for GetViewBoxTransform on root <svg> node
|
|
// * aLength: internal value for our <svg> width or height attribute.
|
|
// * aViewportLength: length of the corresponding dimension of the viewport.
|
|
// * aSelf: the outermost <svg> node itself.
|
|
// NOTE: aSelf is not an ancestor viewport element, so it can't be used to
|
|
// resolve percentage lengths. (It can only be used to resolve
|
|
// 'em'/'ex'-valued units).
|
|
inline float
|
|
ComputeSynthesizedViewBoxDimension(const nsSVGLength2& aLength,
|
|
float aViewportLength,
|
|
const SVGSVGElement* aSelf)
|
|
{
|
|
if (aLength.IsPercentage()) {
|
|
return aViewportLength * aLength.GetAnimValInSpecifiedUnits() / 100.0f;
|
|
}
|
|
|
|
return aLength.GetAnimValue(const_cast<SVGSVGElement*>(aSelf));
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// public helpers:
|
|
|
|
gfx::Matrix
|
|
SVGSVGElement::GetViewBoxTransform() const
|
|
{
|
|
float viewportWidth, viewportHeight;
|
|
if (IsInner()) {
|
|
SVGSVGElement *ctx = GetCtx();
|
|
viewportWidth = mLengthAttributes[ATTR_WIDTH].GetAnimValue(ctx);
|
|
viewportHeight = mLengthAttributes[ATTR_HEIGHT].GetAnimValue(ctx);
|
|
} else {
|
|
viewportWidth = mViewportWidth;
|
|
viewportHeight = mViewportHeight;
|
|
}
|
|
|
|
if (viewportWidth <= 0.0f || viewportHeight <= 0.0f) {
|
|
return gfx::Matrix(0.0, 0.0, 0.0, 0.0, 0.0, 0.0); // singular
|
|
}
|
|
|
|
nsSVGViewBoxRect viewBox =
|
|
GetViewBoxWithSynthesis(viewportWidth, viewportHeight);
|
|
|
|
if (viewBox.width <= 0.0f || viewBox.height <= 0.0f) {
|
|
return gfx::Matrix(0.0, 0.0, 0.0, 0.0, 0.0, 0.0); // singular
|
|
}
|
|
|
|
return SVGContentUtils::GetViewBoxTransform(viewportWidth, viewportHeight,
|
|
viewBox.x, viewBox.y,
|
|
viewBox.width, viewBox.height,
|
|
GetPreserveAspectRatioWithOverride());
|
|
}
|
|
|
|
void
|
|
SVGSVGElement::UpdateHasChildrenOnlyTransform()
|
|
{
|
|
bool hasChildrenOnlyTransform =
|
|
HasViewBoxOrSyntheticViewBox() ||
|
|
(IsRoot() && (mCurrentTranslate != SVGPoint(0.0f, 0.0f) ||
|
|
mCurrentScale != 1.0f));
|
|
mHasChildrenOnlyTransform = hasChildrenOnlyTransform;
|
|
}
|
|
|
|
void
|
|
SVGSVGElement::ChildrenOnlyTransformChanged(uint32_t aFlags)
|
|
{
|
|
// Avoid wasteful calls:
|
|
MOZ_ASSERT(!(GetPrimaryFrame()->GetStateBits() & NS_FRAME_IS_NONDISPLAY),
|
|
"Non-display SVG frames don't maintain overflow rects");
|
|
|
|
nsChangeHint changeHint;
|
|
|
|
bool hadChildrenOnlyTransform = mHasChildrenOnlyTransform;
|
|
|
|
UpdateHasChildrenOnlyTransform();
|
|
|
|
if (hadChildrenOnlyTransform != mHasChildrenOnlyTransform) {
|
|
// Reconstruct the frame tree to handle stacking context changes:
|
|
// XXXjwatt don't do this for root-<svg> or even outer-<svg>?
|
|
changeHint = nsChangeHint_ReconstructFrame;
|
|
} else {
|
|
// We just assume the old and new transforms are different.
|
|
changeHint = nsChangeHint(nsChangeHint_UpdateOverflow |
|
|
nsChangeHint_ChildrenOnlyTransform);
|
|
}
|
|
|
|
// If we're not reconstructing the frame tree, then we only call
|
|
// PostRestyleEvent if we're not being called under reflow to avoid recursing
|
|
// to death. See bug 767056 comments 10 and 12. Since our nsSVGOuterSVGFrame
|
|
// is being reflowed we're going to invalidate and repaint its entire area
|
|
// anyway (which will include our children).
|
|
if ((changeHint & nsChangeHint_ReconstructFrame) ||
|
|
!(aFlags & eDuringReflow)) {
|
|
nsLayoutUtils::PostRestyleEvent(this, nsRestyleHint(0), changeHint);
|
|
}
|
|
}
|
|
|
|
nsresult
|
|
SVGSVGElement::BindToTree(nsIDocument* aDocument,
|
|
nsIContent* aParent,
|
|
nsIContent* aBindingParent,
|
|
bool aCompileEventHandlers)
|
|
{
|
|
nsSMILAnimationController* smilController = nullptr;
|
|
|
|
if (aDocument) {
|
|
smilController = aDocument->GetAnimationController();
|
|
if (smilController) {
|
|
// SMIL is enabled in this document
|
|
if (WillBeOutermostSVG(aParent, aBindingParent)) {
|
|
// We'll be the outermost <svg> element. We'll need a time container.
|
|
if (!mTimedDocumentRoot) {
|
|
mTimedDocumentRoot = new nsSMILTimeContainer();
|
|
}
|
|
} else {
|
|
// We're a child of some other <svg> element, so we don't need our own
|
|
// time container. However, we need to make sure that we'll get a
|
|
// kick-start if we get promoted to be outermost later on.
|
|
mTimedDocumentRoot = nullptr;
|
|
mStartAnimationOnBindToTree = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
nsresult rv = SVGSVGElementBase::BindToTree(aDocument, aParent,
|
|
aBindingParent,
|
|
aCompileEventHandlers);
|
|
NS_ENSURE_SUCCESS(rv,rv);
|
|
|
|
nsIDocument* doc = GetComposedDoc();
|
|
if (doc) {
|
|
// Setup the style sheet during binding, not element construction,
|
|
// because we could move the root SVG element from the document
|
|
// that created it to another document.
|
|
auto cache = nsLayoutStylesheetCache::For(doc->GetStyleBackendType());
|
|
doc->EnsureOnDemandBuiltInUASheet(cache->SVGSheet());
|
|
}
|
|
|
|
if (mTimedDocumentRoot && smilController) {
|
|
rv = mTimedDocumentRoot->SetParent(smilController);
|
|
if (mStartAnimationOnBindToTree) {
|
|
mTimedDocumentRoot->Begin();
|
|
mStartAnimationOnBindToTree = false;
|
|
}
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
void
|
|
SVGSVGElement::UnbindFromTree(bool aDeep, bool aNullParent)
|
|
{
|
|
if (mTimedDocumentRoot) {
|
|
mTimedDocumentRoot->SetParent(nullptr);
|
|
}
|
|
|
|
SVGSVGElementBase::UnbindFromTree(aDeep, aNullParent);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// implementation helpers
|
|
|
|
bool
|
|
SVGSVGElement::WillBeOutermostSVG(nsIContent* aParent,
|
|
nsIContent* aBindingParent) const
|
|
{
|
|
nsIContent* parent = aBindingParent ? aBindingParent : aParent;
|
|
|
|
while (parent && parent->IsSVGElement()) {
|
|
if (parent->IsSVGElement(nsGkAtoms::foreignObject)) {
|
|
// SVG in a foreignObject must have its own <svg> (nsSVGOuterSVGFrame).
|
|
return false;
|
|
}
|
|
if (parent->IsSVGElement(nsGkAtoms::svg)) {
|
|
return false;
|
|
}
|
|
parent = parent->GetParent();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void
|
|
SVGSVGElement::InvalidateTransformNotifyFrame()
|
|
{
|
|
nsISVGSVGFrame* svgframe = do_QueryFrame(GetPrimaryFrame());
|
|
// might fail this check if we've failed conditional processing
|
|
if (svgframe) {
|
|
svgframe->NotifyViewportOrTransformChanged(
|
|
nsISVGChildFrame::TRANSFORM_CHANGED);
|
|
}
|
|
}
|
|
|
|
bool
|
|
SVGSVGElement::HasPreserveAspectRatio()
|
|
{
|
|
return HasAttr(kNameSpaceID_None, nsGkAtoms::preserveAspectRatio) ||
|
|
mPreserveAspectRatio.IsAnimated();
|
|
}
|
|
|
|
SVGViewElement*
|
|
SVGSVGElement::GetCurrentViewElement() const
|
|
{
|
|
if (mCurrentViewID) {
|
|
//XXXsmaug It is unclear how this should work in case we're in Shadow DOM.
|
|
nsIDocument* doc = GetUncomposedDoc();
|
|
if (doc) {
|
|
Element *element = doc->GetElementById(*mCurrentViewID);
|
|
if (element && element->IsSVGElement(nsGkAtoms::view)) {
|
|
return static_cast<SVGViewElement*>(element);
|
|
}
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
nsSVGViewBoxRect
|
|
SVGSVGElement::GetViewBoxWithSynthesis(
|
|
float aViewportWidth, float aViewportHeight) const
|
|
{
|
|
// The logic here should match HasViewBoxRect().
|
|
SVGViewElement* viewElement = GetCurrentViewElement();
|
|
if (viewElement && viewElement->mViewBox.HasRect()) {
|
|
return viewElement->mViewBox.GetAnimValue();
|
|
}
|
|
if (mSVGView && mSVGView->mViewBox.HasRect()) {
|
|
return mSVGView->mViewBox.GetAnimValue();
|
|
}
|
|
if (mViewBox.HasRect()) {
|
|
return mViewBox.GetAnimValue();
|
|
}
|
|
|
|
if (ShouldSynthesizeViewBox()) {
|
|
// Special case -- fake a viewBox, using height & width attrs.
|
|
// (Use |this| as context, since if we get here, we're outermost <svg>.)
|
|
return nsSVGViewBoxRect(0, 0,
|
|
ComputeSynthesizedViewBoxDimension(mLengthAttributes[ATTR_WIDTH],
|
|
mViewportWidth, this),
|
|
ComputeSynthesizedViewBoxDimension(mLengthAttributes[ATTR_HEIGHT],
|
|
mViewportHeight, this));
|
|
|
|
}
|
|
|
|
// No viewBox attribute, so we shouldn't auto-scale. This is equivalent
|
|
// to having a viewBox that exactly matches our viewport size.
|
|
return nsSVGViewBoxRect(0, 0, aViewportWidth, aViewportHeight);
|
|
}
|
|
|
|
SVGPreserveAspectRatio
|
|
SVGSVGElement::GetPreserveAspectRatioWithOverride() const
|
|
{
|
|
nsIDocument* doc = GetUncomposedDoc();
|
|
if (doc && doc->IsBeingUsedAsImage()) {
|
|
const SVGPreserveAspectRatio *pAROverridePtr = GetPreserveAspectRatioProperty();
|
|
if (pAROverridePtr) {
|
|
return *pAROverridePtr;
|
|
}
|
|
}
|
|
|
|
SVGViewElement* viewElement = GetCurrentViewElement();
|
|
|
|
// This check is equivalent to "!HasViewBoxRect() && ShouldSynthesizeViewBox()".
|
|
// We're just holding onto the viewElement that HasViewBoxRect() would look up,
|
|
// so that we don't have to look it up again later.
|
|
if (!((viewElement && viewElement->mViewBox.HasRect()) ||
|
|
(mSVGView && mSVGView->mViewBox.HasRect()) ||
|
|
mViewBox.HasRect()) &&
|
|
ShouldSynthesizeViewBox()) {
|
|
// If we're synthesizing a viewBox, use preserveAspectRatio="none";
|
|
return SVGPreserveAspectRatio(SVG_PRESERVEASPECTRATIO_NONE, SVG_MEETORSLICE_SLICE);
|
|
}
|
|
|
|
if (viewElement && viewElement->mPreserveAspectRatio.IsExplicitlySet()) {
|
|
return viewElement->mPreserveAspectRatio.GetAnimValue();
|
|
}
|
|
if (mSVGView && mSVGView->mPreserveAspectRatio.IsExplicitlySet()) {
|
|
return mSVGView->mPreserveAspectRatio.GetAnimValue();
|
|
}
|
|
return mPreserveAspectRatio.GetAnimValue();
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// SVGSVGElement
|
|
|
|
float
|
|
SVGSVGElement::GetLength(uint8_t aCtxType)
|
|
{
|
|
float h, w;
|
|
|
|
SVGViewElement* viewElement = GetCurrentViewElement();
|
|
const nsSVGViewBoxRect* viewbox = nullptr;
|
|
|
|
// The logic here should match HasViewBoxRect().
|
|
if (viewElement && viewElement->mViewBox.HasRect()) {
|
|
viewbox = &viewElement->mViewBox.GetAnimValue();
|
|
} else if (mSVGView && mSVGView->mViewBox.HasRect()) {
|
|
viewbox = &mSVGView->mViewBox.GetAnimValue();
|
|
} else if (mViewBox.HasRect()) {
|
|
viewbox = &mViewBox.GetAnimValue();
|
|
}
|
|
|
|
if (viewbox) {
|
|
w = viewbox->width;
|
|
h = viewbox->height;
|
|
} else if (IsInner()) {
|
|
SVGSVGElement *ctx = GetCtx();
|
|
w = mLengthAttributes[ATTR_WIDTH].GetAnimValue(ctx);
|
|
h = mLengthAttributes[ATTR_HEIGHT].GetAnimValue(ctx);
|
|
} else if (ShouldSynthesizeViewBox()) {
|
|
w = ComputeSynthesizedViewBoxDimension(mLengthAttributes[ATTR_WIDTH],
|
|
mViewportWidth, this);
|
|
h = ComputeSynthesizedViewBoxDimension(mLengthAttributes[ATTR_HEIGHT],
|
|
mViewportHeight, this);
|
|
} else {
|
|
w = mViewportWidth;
|
|
h = mViewportHeight;
|
|
}
|
|
|
|
w = std::max(w, 0.0f);
|
|
h = std::max(h, 0.0f);
|
|
|
|
switch (aCtxType) {
|
|
case SVGContentUtils::X:
|
|
return w;
|
|
case SVGContentUtils::Y:
|
|
return h;
|
|
case SVGContentUtils::XY:
|
|
return float(SVGContentUtils::ComputeNormalizedHypotenuse(w, h));
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// nsSVGElement methods
|
|
|
|
/* virtual */ gfxMatrix
|
|
SVGSVGElement::PrependLocalTransformsTo(
|
|
const gfxMatrix &aMatrix, SVGTransformTypes aWhich) const
|
|
{
|
|
// 'transform' attribute (or an override from a fragment identifier):
|
|
gfxMatrix fromUserSpace =
|
|
SVGContentUtils::PrependLocalTransformsTo(
|
|
aMatrix, aWhich, mAnimateMotionTransform,
|
|
mSVGView && mSVGView->mTransforms ? mSVGView->mTransforms : mTransforms);
|
|
|
|
if (aWhich == eUserSpaceToParent) {
|
|
return fromUserSpace;
|
|
}
|
|
|
|
if (IsInner()) {
|
|
float x, y;
|
|
const_cast<SVGSVGElement*>(this)->GetAnimatedLengthValues(&x, &y, nullptr);
|
|
if (aWhich == eAllTransforms) {
|
|
// the common case
|
|
return ThebesMatrix(GetViewBoxTransform()) * gfxMatrix::Translation(x, y) * fromUserSpace;
|
|
}
|
|
MOZ_ASSERT(aWhich == eChildToUserSpace, "Unknown TransformTypes");
|
|
return ThebesMatrix(GetViewBoxTransform()) * gfxMatrix::Translation(x, y) * aMatrix;
|
|
}
|
|
|
|
if (IsRoot()) {
|
|
gfxMatrix zoomPanTM;
|
|
zoomPanTM.Translate(gfxPoint(mCurrentTranslate.GetX(), mCurrentTranslate.GetY()));
|
|
zoomPanTM.Scale(mCurrentScale, mCurrentScale);
|
|
return ThebesMatrix(GetViewBoxTransform()) * zoomPanTM * fromUserSpace;
|
|
}
|
|
|
|
// outer-<svg>, but inline in some other content:
|
|
return ThebesMatrix(GetViewBoxTransform()) * fromUserSpace;
|
|
}
|
|
|
|
nsSVGAnimatedTransformList*
|
|
SVGSVGElement::GetAnimatedTransformList(uint32_t aFlags)
|
|
{
|
|
if (!(aFlags & DO_ALLOCATE) && mSVGView && mSVGView->mTransforms) {
|
|
return mSVGView->mTransforms;
|
|
}
|
|
return SVGSVGElementBase::GetAnimatedTransformList(aFlags);
|
|
}
|
|
|
|
/* virtual */ bool
|
|
SVGSVGElement::HasValidDimensions() const
|
|
{
|
|
return !IsInner() ||
|
|
((!mLengthAttributes[ATTR_WIDTH].IsExplicitlySet() ||
|
|
mLengthAttributes[ATTR_WIDTH].GetAnimValInSpecifiedUnits() > 0) &&
|
|
(!mLengthAttributes[ATTR_HEIGHT].IsExplicitlySet() ||
|
|
mLengthAttributes[ATTR_HEIGHT].GetAnimValInSpecifiedUnits() > 0));
|
|
}
|
|
|
|
nsSVGElement::LengthAttributesInfo
|
|
SVGSVGElement::GetLengthInfo()
|
|
{
|
|
return LengthAttributesInfo(mLengthAttributes, sLengthInfo,
|
|
ArrayLength(sLengthInfo));
|
|
}
|
|
|
|
nsSVGElement::EnumAttributesInfo
|
|
SVGSVGElement::GetEnumInfo()
|
|
{
|
|
return EnumAttributesInfo(mEnumAttributes, sEnumInfo,
|
|
ArrayLength(sEnumInfo));
|
|
}
|
|
|
|
nsSVGViewBox*
|
|
SVGSVGElement::GetViewBox()
|
|
{
|
|
return &mViewBox;
|
|
}
|
|
|
|
SVGAnimatedPreserveAspectRatio *
|
|
SVGSVGElement::GetPreserveAspectRatio()
|
|
{
|
|
return &mPreserveAspectRatio;
|
|
}
|
|
|
|
bool
|
|
SVGSVGElement::HasViewBoxRect() const
|
|
{
|
|
SVGViewElement* viewElement = GetCurrentViewElement();
|
|
if ((viewElement && viewElement->mViewBox.HasRect()) ||
|
|
(mSVGView && mSVGView->mViewBox.HasRect())) {
|
|
return true;
|
|
}
|
|
return mViewBox.HasRect();
|
|
}
|
|
|
|
bool
|
|
SVGSVGElement::ShouldSynthesizeViewBox() const
|
|
{
|
|
MOZ_ASSERT(!HasViewBoxRect(),
|
|
"Should only be called if we lack a viewBox");
|
|
|
|
nsIDocument* doc = GetUncomposedDoc();
|
|
return doc &&
|
|
doc->IsBeingUsedAsImage() &&
|
|
!mIsPaintingSVGImageElement &&
|
|
!GetParent();
|
|
}
|
|
|
|
bool
|
|
SVGSVGElement::SetPreserveAspectRatioProperty(const SVGPreserveAspectRatio& aPAR)
|
|
{
|
|
SVGPreserveAspectRatio* pAROverridePtr = new SVGPreserveAspectRatio(aPAR);
|
|
nsresult rv = SetProperty(nsGkAtoms::overridePreserveAspectRatio,
|
|
pAROverridePtr,
|
|
nsINode::DeleteProperty<SVGPreserveAspectRatio>,
|
|
true);
|
|
MOZ_ASSERT(rv != NS_PROPTABLE_PROP_OVERWRITTEN,
|
|
"Setting override value when it's already set...?");
|
|
|
|
if (MOZ_UNLIKELY(NS_FAILED(rv))) {
|
|
// property-insertion failed (e.g. OOM in property-table code)
|
|
delete pAROverridePtr;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
const SVGPreserveAspectRatio*
|
|
SVGSVGElement::GetPreserveAspectRatioProperty() const
|
|
{
|
|
void* valPtr = GetProperty(nsGkAtoms::overridePreserveAspectRatio);
|
|
if (valPtr) {
|
|
return static_cast<SVGPreserveAspectRatio*>(valPtr);
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
bool
|
|
SVGSVGElement::ClearPreserveAspectRatioProperty()
|
|
{
|
|
void* valPtr = UnsetProperty(nsGkAtoms::overridePreserveAspectRatio);
|
|
delete static_cast<SVGPreserveAspectRatio*>(valPtr);
|
|
return valPtr;
|
|
}
|
|
|
|
void
|
|
SVGSVGElement::SetIsPaintingForSVGImageElement(bool aIsPaintingSVGImageElement)
|
|
{
|
|
mIsPaintingSVGImageElement = aIsPaintingSVGImageElement;
|
|
}
|
|
|
|
void
|
|
SVGSVGElement::
|
|
SetImageOverridePreserveAspectRatio(const SVGPreserveAspectRatio& aPAR)
|
|
{
|
|
#ifdef DEBUG
|
|
MOZ_ASSERT(OwnerDoc()->IsBeingUsedAsImage(),
|
|
"should only override preserveAspectRatio in images");
|
|
#endif
|
|
|
|
bool hasViewBoxRect = HasViewBoxRect();
|
|
if (!hasViewBoxRect && ShouldSynthesizeViewBox()) {
|
|
// My non-<svg:image> clients will have been painting me with a synthesized
|
|
// viewBox, but my <svg:image> client that's about to paint me now does NOT
|
|
// want that. Need to tell ourselves to flush our transform.
|
|
mImageNeedsTransformInvalidation = true;
|
|
}
|
|
|
|
if (!hasViewBoxRect) {
|
|
return; // preserveAspectRatio irrelevant (only matters if we have viewBox)
|
|
}
|
|
|
|
if (SetPreserveAspectRatioProperty(aPAR)) {
|
|
mImageNeedsTransformInvalidation = true;
|
|
}
|
|
}
|
|
|
|
void
|
|
SVGSVGElement::ClearImageOverridePreserveAspectRatio()
|
|
{
|
|
#ifdef DEBUG
|
|
MOZ_ASSERT(OwnerDoc()->IsBeingUsedAsImage(),
|
|
"should only override image preserveAspectRatio in images");
|
|
#endif
|
|
|
|
if (!HasViewBoxRect() && ShouldSynthesizeViewBox()) {
|
|
// My non-<svg:image> clients will want to paint me with a synthesized
|
|
// viewBox, but my <svg:image> client that just painted me did NOT
|
|
// use that. Need to tell ourselves to flush our transform.
|
|
mImageNeedsTransformInvalidation = true;
|
|
}
|
|
|
|
if (ClearPreserveAspectRatioProperty()) {
|
|
mImageNeedsTransformInvalidation = true;
|
|
}
|
|
}
|
|
|
|
void
|
|
SVGSVGElement::FlushImageTransformInvalidation()
|
|
{
|
|
MOZ_ASSERT(!GetParent(), "Should only be called on root node");
|
|
MOZ_ASSERT(OwnerDoc()->IsBeingUsedAsImage(),
|
|
"Should only be called on image documents");
|
|
|
|
if (mImageNeedsTransformInvalidation) {
|
|
InvalidateTransformNotifyFrame();
|
|
mImageNeedsTransformInvalidation = false;
|
|
}
|
|
}
|
|
|
|
int32_t
|
|
SVGSVGElement::GetIntrinsicWidth()
|
|
{
|
|
if (mLengthAttributes[ATTR_WIDTH].IsPercentage()) {
|
|
return -1;
|
|
}
|
|
// Passing |this| as a SVGSVGElement* invokes the variant of GetAnimValue
|
|
// that uses the passed argument as the context, but that's fine since we
|
|
// know the length isn't a percentage so the context won't be used (and we
|
|
// need to pass the element to be able to resolve em/ex units).
|
|
float width = mLengthAttributes[ATTR_WIDTH].GetAnimValue(this);
|
|
return nsSVGUtils::ClampToInt(width);
|
|
}
|
|
|
|
int32_t
|
|
SVGSVGElement::GetIntrinsicHeight()
|
|
{
|
|
if (mLengthAttributes[ATTR_HEIGHT].IsPercentage()) {
|
|
return -1;
|
|
}
|
|
// Passing |this| as a SVGSVGElement* invokes the variant of GetAnimValue
|
|
// that uses the passed argument as the context, but that's fine since we
|
|
// know the length isn't a percentage so the context won't be used (and we
|
|
// need to pass the element to be able to resolve em/ex units).
|
|
float height = mLengthAttributes[ATTR_HEIGHT].GetAnimValue(this);
|
|
return nsSVGUtils::ClampToInt(height);
|
|
}
|
|
|
|
} // namespace dom
|
|
} // namespace mozilla
|