#include "config.h"
#if ENABLE(SVG)
#include "SVGUseElement.h"
#include "CSSStyleSelector.h"
#include "CString.h"
#include "Document.h"
#include "Event.h"
#include "HTMLNames.h"
#include "RenderSVGTransformableContainer.h"
#include "SVGElementInstance.h"
#include "SVGElementInstanceList.h"
#include "SVGGElement.h"
#include "SVGLength.h"
#include "SVGNames.h"
#include "SVGPreserveAspectRatio.h"
#include "SVGSVGElement.h"
#include "SVGSymbolElement.h"
#include "XLinkNames.h"
#include "XMLSerializer.h"
#include <wtf/OwnPtr.h>
namespace WebCore {
SVGUseElement::SVGUseElement(const QualifiedName& tagName, Document* doc)
: SVGStyledTransformableElement(tagName, doc)
, SVGTests()
, SVGLangSpace()
, SVGExternalResourcesRequired()
, SVGURIReference()
, m_x(this, LengthModeWidth)
, m_y(this, LengthModeHeight)
, m_width(this, LengthModeWidth)
, m_height(this, LengthModeHeight)
{
}
SVGUseElement::~SVGUseElement()
{
}
ANIMATED_PROPERTY_DEFINITIONS(SVGUseElement, SVGLength, Length, length, X, x, SVGNames::xAttr, m_x)
ANIMATED_PROPERTY_DEFINITIONS(SVGUseElement, SVGLength, Length, length, Y, y, SVGNames::yAttr, m_y)
ANIMATED_PROPERTY_DEFINITIONS(SVGUseElement, SVGLength, Length, length, Width, width, SVGNames::widthAttr, m_width)
ANIMATED_PROPERTY_DEFINITIONS(SVGUseElement, SVGLength, Length, length, Height, height, SVGNames::heightAttr, m_height)
SVGElementInstance* SVGUseElement::instanceRoot() const
{
return m_targetElementInstance.get();
}
SVGElementInstance* SVGUseElement::animatedInstanceRoot() const
{
return 0;
}
void SVGUseElement::parseMappedAttribute(MappedAttribute* attr)
{
if (attr->name() == SVGNames::xAttr)
setXBaseValue(SVGLength(this, LengthModeWidth, attr->value()));
else if (attr->name() == SVGNames::yAttr)
setYBaseValue(SVGLength(this, LengthModeHeight, attr->value()));
else if (attr->name() == SVGNames::widthAttr) {
setWidthBaseValue(SVGLength(this, LengthModeWidth, attr->value()));
if (width().value() < 0.0)
document()->accessSVGExtensions()->reportError("A negative value for use attribute <width> is not allowed");
} else if (attr->name() == SVGNames::heightAttr) {
setHeightBaseValue(SVGLength(this, LengthModeHeight, attr->value()));
if (height().value() < 0.0)
document()->accessSVGExtensions()->reportError("A negative value for use attribute <height> is not allowed");
} else {
if (SVGTests::parseMappedAttribute(attr))
return;
if (SVGLangSpace::parseMappedAttribute(attr))
return;
if (SVGExternalResourcesRequired::parseMappedAttribute(attr))
return;
if (SVGURIReference::parseMappedAttribute(attr))
return;
SVGStyledTransformableElement::parseMappedAttribute(attr);
}
}
void SVGUseElement::insertedIntoDocument()
{
SVGElement::insertedIntoDocument();
buildPendingResource();
}
void SVGUseElement::removedFromDocument()
{
SVGElement::removedFromDocument();
m_targetElementInstance = 0;
m_shadowTreeRootElement = 0;
}
void SVGUseElement::svgAttributeChanged(const QualifiedName& attrName)
{
SVGStyledTransformableElement::svgAttributeChanged(attrName);
if (!attached())
return;
if (attrName == SVGNames::xAttr || attrName == SVGNames::yAttr ||
attrName == SVGNames::widthAttr || attrName == SVGNames::heightAttr ||
SVGTests::isKnownAttribute(attrName) ||
SVGLangSpace::isKnownAttribute(attrName) ||
SVGExternalResourcesRequired::isKnownAttribute(attrName) ||
SVGURIReference::isKnownAttribute(attrName) ||
SVGStyledTransformableElement::isKnownAttribute(attrName)) {
buildPendingResource();
if (m_shadowTreeRootElement)
m_shadowTreeRootElement->setChanged();
}
}
void SVGUseElement::childrenChanged(bool changedByParser)
{
SVGElement::childrenChanged(changedByParser);
if (!attached())
return;
buildPendingResource();
if (m_shadowTreeRootElement)
m_shadowTreeRootElement->setChanged();
}
void SVGUseElement::recalcStyle(StyleChange change)
{
SVGStyledElement::recalcStyle(change);
if (!m_shadowTreeRootElement || !m_shadowTreeRootElement->attached())
return;
if (change >= Inherit || m_shadowTreeRootElement->changed()) {
RenderStyle* newStyle = document()->styleSelector()->styleForElement(m_shadowTreeRootElement.get());
StyleChange ch = m_shadowTreeRootElement->diff(m_shadowTreeRootElement->renderStyle(), newStyle);
if (ch == Detach) {
ASSERT(m_shadowTreeRootElement->attached());
m_shadowTreeRootElement->detach();
attachShadowTree();
m_shadowTreeRootElement->setChanged(NoStyleChange);
m_shadowTreeRootElement->setHasChangedChild(false);
newStyle->deref(document()->renderArena());
return;
}
newStyle->deref(document()->renderArena());
}
m_shadowTreeRootElement->recalcStyle(change);
}
#ifdef DUMP_INSTANCE_TREE
void dumpInstanceTree(unsigned int& depth, String& text, SVGElementInstance* targetInstance)
{
SVGElement* element = targetInstance->correspondingElement();
ASSERT(element);
String elementId = element->getIDAttribute();
String elementNodeName = element->nodeName();
String parentNodeName = element->parentNode() ? element->parentNode()->nodeName() : "null";
String firstChildNodeName = element->firstChild() ? element->firstChild()->nodeName() : "null";
for (unsigned int i = 0; i < depth; ++i)
text += " ";
text += String::format("SVGElementInstance (parentNode=%s, firstChild=%s, correspondingElement=%s, id=%s)\n",
parentNodeName.latin1().data(), firstChildNodeName.latin1().data(), elementNodeName.latin1().data(), elementId.latin1().data());
depth++;
for (SVGElementInstance* instance = targetInstance->firstChild(); instance; instance = instance->nextSibling())
dumpInstanceTree(depth, text, instance);
depth--;
}
#endif
static bool isDisallowedElement(Node* element)
{
#if ENABLE(SVG_FOREIGN_OBJECT)
if (element->hasTagName(SVGNames::foreignObjectTag))
return true;
#endif
return false;
}
static bool subtreeContainsDisallowedElement(Node* start)
{
if (isDisallowedElement(start))
return true;
for (Node* cur = start->firstChild(); cur; cur = cur->nextSibling()) {
if (subtreeContainsDisallowedElement(cur))
return true;
}
return false;
}
void SVGUseElement::buildPendingResource()
{
String id = SVGURIReference::getTarget(href());
Element* targetElement = document()->getElementById(id);
if (!targetElement) {
document()->accessSVGExtensions()->addPendingResource(id, this);
return;
}
Node* parent = parentNode();
while (parent) {
if (parent->isShadowNode())
return;
parent = parent->parentNode();
}
SVGElement* target = 0;
if (targetElement && targetElement->isSVGElement())
target = static_cast<SVGElement*>(targetElement);
if (!target || target == this) {
m_targetElementInstance = 0;
m_shadowTreeRootElement = 0;
return;
}
m_targetElementInstance = new SVGElementInstance(this, target);
bool foundProblem = false;
buildInstanceTree(target, m_targetElementInstance.get(), foundProblem);
if (foundProblem) {
m_targetElementInstance = 0;
m_shadowTreeRootElement = 0;
return;
}
ASSERT(m_targetElementInstance);
ASSERT(m_targetElementInstance->correspondingUseElement() == this);
m_shadowTreeRootElement = new SVGGElement(SVGNames::gTag, document());
m_shadowTreeRootElement->setInDocument();
m_shadowTreeRootElement->setShadowParentNode(this);
if (x().value() != 0.0 || y().value() != 0.0) {
String transformString = String::format("translate(%f, %f)", x().value(), y().value());
m_shadowTreeRootElement->setAttribute(SVGNames::transformAttr, transformString);
}
buildShadowTree(target, m_targetElementInstance.get());
#if ENABLE(SVG) && ENABLE(SVG_USE)
expandUseElementsInShadowTree(m_shadowTreeRootElement.get());
expandSymbolElementsInShadowTree(m_shadowTreeRootElement.get());
#endif
associateInstancesWithShadowTreeElements(m_shadowTreeRootElement->firstChild(), m_targetElementInstance.get());
#ifdef DUMP_INSTANCE_TREE
String text;
unsigned int depth = 0;
dumpInstanceTree(depth, text, m_targetElementInstance.get());
fprintf(stderr, "\nDumping <use> instance tree:\n%s\n", text.latin1().data());
#endif
#ifdef DUMP_SHADOW_TREE
ExceptionCode ec = 0;
OwnPtr<XMLSerializer> serializer(new XMLSerializer());
String markup = serializer->serializeToString(m_shadowTreeRootElement.get(), ec);
ASSERT(ec == 0);
fprintf(stderr, "Dumping <use> shadow tree markup:\n%s\n", markup.latin1().data());
#endif
attachShadowTree();
}
RenderObject* SVGUseElement::createRenderer(RenderArena* arena, RenderStyle*)
{
return new (arena) RenderSVGTransformableContainer(this);
}
void SVGUseElement::attach()
{
SVGStyledTransformableElement::attach();
attachShadowTree();
}
void SVGUseElement::detach()
{
SVGStyledTransformableElement::detach();
if (m_shadowTreeRootElement)
m_shadowTreeRootElement->detach();
}
static bool isDirectReference(Node* n)
{
return n->hasTagName(SVGNames::pathTag) ||
n->hasTagName(SVGNames::rectTag) ||
n->hasTagName(SVGNames::circleTag) ||
n->hasTagName(SVGNames::ellipseTag) ||
n->hasTagName(SVGNames::polygonTag) ||
n->hasTagName(SVGNames::polylineTag) ||
n->hasTagName(SVGNames::textTag);
}
Path SVGUseElement::toClipPath() const
{
if (!m_shadowTreeRootElement)
const_cast<SVGUseElement*>(this)->buildPendingResource();
Node* n = m_shadowTreeRootElement->firstChild();
if (n->isSVGElement() && static_cast<SVGElement*>(n)->isStyledTransformable()) {
if (!isDirectReference(n))
document()->accessSVGExtensions()->reportError("Not allowed to use indirect reference in <clip-path>");
else
return static_cast<SVGStyledTransformableElement*>(n)->toClipPath();
}
return Path();
}
void SVGUseElement::buildInstanceTree(SVGElement* target, SVGElementInstance* targetInstance, bool& foundProblem)
{
ASSERT(target);
ASSERT(targetInstance);
for (Node* node = target->firstChild(); node; node = node->nextSibling()) {
SVGElement* element = 0;
if (node->isSVGElement())
element = static_cast<SVGElement*>(node);
if (!element || isDisallowedElement(element))
continue;
SVGElementInstance* instancePtr = new SVGElementInstance(this, element);
RefPtr<SVGElementInstance> instance = instancePtr;
targetInstance->appendChild(instance.release());
if (element->hasChildNodes())
buildInstanceTree(element, instancePtr, foundProblem);
if (element->hasTagName(SVGNames::useTag))
handleDeepUseReferencing(element, instancePtr, foundProblem);
}
if (target->hasTagName(SVGNames::useTag))
handleDeepUseReferencing(target, targetInstance, foundProblem);
}
void SVGUseElement::handleDeepUseReferencing(SVGElement* use, SVGElementInstance* targetInstance, bool& foundProblem)
{
String id = SVGURIReference::getTarget(use->href());
Element* targetElement = document()->getElementById(id);
SVGElement* target = 0;
if (targetElement && targetElement->isSVGElement())
target = static_cast<SVGElement*>(targetElement);
if (!target)
return;
foundProblem = (target == this);
if (foundProblem)
return;
SVGElementInstance* instance = targetInstance->parentNode();
while (instance) {
SVGElement* element = instance->correspondingElement();
if (element->getIDAttribute() == id) {
foundProblem = true;
return;
}
instance = instance->parentNode();
}
SVGElementInstance* newInstance = new SVGElementInstance(this, target);
targetInstance->appendChild(newInstance);
buildInstanceTree(target, newInstance, foundProblem);
}
void SVGUseElement::alterShadowTreeForSVGTag(SVGElement* target)
{
String widthString = String::number(width().value());
String heightString = String::number(height().value());
if (hasAttribute(SVGNames::widthAttr))
target->setAttribute(SVGNames::widthAttr, widthString);
if (hasAttribute(SVGNames::heightAttr))
target->setAttribute(SVGNames::heightAttr, heightString);
}
void SVGUseElement::removeDisallowedElementsFromSubtree(Node* element)
{
ExceptionCode ec = 0;
for (RefPtr<Node> child = element->firstChild(); child; child = child->nextSibling()) {
if (isDisallowedElement(child.get())) {
ASSERT(child->parent());
child->parent()->removeChild(child.get(), ec);
ASSERT(ec == 0);
continue;
}
if (child->hasChildNodes())
removeDisallowedElementsFromSubtree(child.get());
}
}
void SVGUseElement::buildShadowTree(SVGElement* target, SVGElementInstance* targetInstance)
{
if (isDisallowedElement(target))
return;
RefPtr<Node> newChild = targetInstance->correspondingElement()->cloneNode(true);
if (subtreeContainsDisallowedElement(newChild.get()))
removeDisallowedElementsFromSubtree(newChild.get());
SVGElement* newChildPtr = 0;
if (newChild->isSVGElement())
newChildPtr = static_cast<SVGElement*>(newChild.get());
ASSERT(newChildPtr);
ExceptionCode ec = 0;
m_shadowTreeRootElement->appendChild(newChild.release(), ec);
ASSERT(ec == 0);
if (target->hasTagName(SVGNames::svgTag))
alterShadowTreeForSVGTag(newChildPtr);
}
#if ENABLE(SVG) && ENABLE(SVG_USE)
void SVGUseElement::expandUseElementsInShadowTree(Node* element)
{
if (element->hasTagName(SVGNames::useTag)) {
SVGUseElement* use = static_cast<SVGUseElement*>(element);
String id = SVGURIReference::getTarget(use->href());
Element* targetElement = document()->getElementById(id);
SVGElement* target = 0;
if (targetElement && targetElement->isSVGElement())
target = static_cast<SVGElement*>(targetElement);
if (target) {
RefPtr<SVGElement> cloneParent = new SVGGElement(SVGNames::gTag, document());
transferUseAttributesToReplacedElement(use, cloneParent.get());
if (use->x().value() != 0.0 || use->y().value() != 0.0) {
if (!cloneParent->hasAttribute(SVGNames::transformAttr)) {
String transformString = String::format("translate(%f, %f)", use->x().value(), use->y().value());
cloneParent->setAttribute(SVGNames::transformAttr, transformString);
} else {
String transformString = String::format(" translate(%f, %f)", use->x().value(), use->y().value());
const AtomicString& transformAttribute = cloneParent->getAttribute(SVGNames::transformAttr);
cloneParent->setAttribute(SVGNames::transformAttr, transformAttribute + transformString);
}
}
ExceptionCode ec = 0;
if (isDisallowedElement(target)) {
ASSERT(use->parentNode());
use->parentNode()->replaceChild(cloneParent.release(), use, ec);
ASSERT(ec == 0);
return;
}
RefPtr<Node> newChild = target->cloneNode(true);
if (subtreeContainsDisallowedElement(newChild.get()))
removeDisallowedElementsFromSubtree(newChild.get());
SVGElement* newChildPtr = 0;
if (newChild->isSVGElement())
newChildPtr = static_cast<SVGElement*>(newChild.get());
ASSERT(newChildPtr);
cloneParent->appendChild(newChild.release(), ec);
ASSERT(ec == 0);
ASSERT(use->parentNode());
use->parentNode()->replaceChild(cloneParent.release(), use, ec);
ASSERT(ec == 0);
if (target->hasTagName(SVGNames::svgTag))
alterShadowTreeForSVGTag(newChildPtr);
expandUseElementsInShadowTree(m_shadowTreeRootElement.get());
return;
}
}
for (RefPtr<Node> child = element->firstChild(); child; child = child->nextSibling())
expandUseElementsInShadowTree(child.get());
}
void SVGUseElement::expandSymbolElementsInShadowTree(Node* element)
{
if (element->hasTagName(SVGNames::symbolTag)) {
RefPtr<SVGSVGElement> svgElement = new SVGSVGElement(SVGNames::svgTag, document());
*svgElement->attributes() = *element->attributes();
String widthString = String::number(width().value());
String heightString = String::number(height().value());
svgElement->setAttribute(SVGNames::widthAttr, hasAttribute(SVGNames::widthAttr) ? widthString : "100%");
svgElement->setAttribute(SVGNames::heightAttr, hasAttribute(SVGNames::heightAttr) ? heightString : "100%");
ExceptionCode ec = 0;
for (Node* child = element->firstChild(); child; child = child->nextSibling()) {
RefPtr<Node> newChild = child->cloneNode(true);
svgElement->appendChild(newChild.release(), ec);
ASSERT(ec == 0);
}
if (subtreeContainsDisallowedElement(svgElement.get()))
removeDisallowedElementsFromSubtree(svgElement.get());
ASSERT(element->parentNode());
element->parentNode()->replaceChild(svgElement.release(), element, ec);
ASSERT(ec == 0);
expandSymbolElementsInShadowTree(m_shadowTreeRootElement.get());
return;
}
for (RefPtr<Node> child = element->firstChild(); child; child = child->nextSibling())
expandSymbolElementsInShadowTree(child.get());
}
#endif
void SVGUseElement::attachShadowTree()
{
if (!m_shadowTreeRootElement || m_shadowTreeRootElement->attached() || !document()->shouldCreateRenderers() || !attached() || !renderer())
return;
if (renderer()->canHaveChildren() && childShouldCreateRenderer(m_shadowTreeRootElement.get())) {
RenderStyle* style = m_shadowTreeRootElement->styleForRenderer(renderer());
if (m_shadowTreeRootElement->rendererIsNeeded(style)) {
m_shadowTreeRootElement->setRenderer(m_shadowTreeRootElement->createRenderer(document()->renderArena(), style));
if (RenderObject* shadowRenderer = m_shadowTreeRootElement->renderer()) {
shadowRenderer->setStyle(style);
renderer()->addChild(shadowRenderer, m_shadowTreeRootElement->nextRenderer());
m_shadowTreeRootElement->setAttached();
}
}
style->deref(document()->renderArena());
for (Node* child = m_shadowTreeRootElement->firstChild(); child; child = child->nextSibling())
child->attach();
}
}
void SVGUseElement::associateInstancesWithShadowTreeElements(Node* target, SVGElementInstance* targetInstance)
{
if (!target || !targetInstance)
return;
SVGElement* originalElement = targetInstance->correspondingElement();
if (originalElement->hasTagName(SVGNames::useTag)) {
#if ENABLE(SVG) && ENABLE(SVG_USE)
ASSERT(target->nodeName() == SVGNames::gTag);
#else
ASSERT(target->nodeName() == SVGNames::gTag || target->nodeName() == SVGNames::useTag);
#endif
} else if (originalElement->hasTagName(SVGNames::symbolTag)) {
ASSERT(target->nodeName() == SVGNames::svgTag);
} else
ASSERT(target->nodeName() == originalElement->nodeName());
SVGElement* element = 0;
if (target->isSVGElement())
element = static_cast<SVGElement*>(target);
ASSERT(!targetInstance->shadowTreeElement());
targetInstance->setShadowTreeElement(element);
Node* node = target->firstChild();
for (SVGElementInstance* instance = targetInstance->firstChild(); node && instance; instance = instance->nextSibling()) {
while (node && !node->isSVGElement())
node = node->nextSibling();
associateInstancesWithShadowTreeElements(node, instance);
node = node->nextSibling();
}
}
SVGElementInstance* SVGUseElement::instanceForShadowTreeElement(Node* element) const
{
return instanceForShadowTreeElement(element, m_targetElementInstance.get());
}
SVGElementInstance* SVGUseElement::instanceForShadowTreeElement(Node* element, SVGElementInstance* instance) const
{
ASSERT(element);
ASSERT(instance);
ASSERT(instance->shadowTreeElement());
if (element == instance->shadowTreeElement())
return instance;
for (SVGElementInstance* current = instance->firstChild(); current; current = current->nextSibling()) {
SVGElementInstance* search = instanceForShadowTreeElement(element, current);
if (search)
return search;
}
return 0;
}
void SVGUseElement::transferUseAttributesToReplacedElement(SVGElement* from, SVGElement* to) const
{
ASSERT(from);
ASSERT(to);
*to->attributes() = *from->attributes();
ExceptionCode ec = 0;
to->removeAttribute(SVGNames::xAttr, ec);
ASSERT(ec == 0);
to->removeAttribute(SVGNames::yAttr, ec);
ASSERT(ec == 0);
to->removeAttribute(SVGNames::widthAttr, ec);
ASSERT(ec == 0);
to->removeAttribute(SVGNames::heightAttr, ec);
ASSERT(ec == 0);
to->removeAttribute(XLinkNames::hrefAttr, ec);
ASSERT(ec == 0);
}
}
#endif // ENABLE(SVG)