diff -r 000000000000 -r 4f2f89ce4247 WebCore/svg/SVGElement.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/WebCore/svg/SVGElement.cpp Fri Sep 17 09:02:29 2010 +0300 @@ -0,0 +1,341 @@ +/* + Copyright (C) 2004, 2005, 2006, 2007, 2008 Nikolas Zimmermann + 2004, 2005, 2006, 2008 Rob Buis + Copyright (C) 2008 Apple Inc. All rights reserved. + Copyright (C) 2008 Alp Toker + Copyright (C) 2009 Cameron McCormack + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include "config.h" + +#if ENABLE(SVG) +#include "SVGElement.h" + +#include "Attribute.h" +#include "CSSCursorImageValue.h" +#include "DOMImplementation.h" +#include "Document.h" +#include "Event.h" +#include "EventListener.h" +#include "EventNames.h" +#include "FrameView.h" +#include "HTMLNames.h" +#include "RegisteredEventListener.h" +#include "RenderObject.h" +#include "SVGCursorElement.h" +#include "SVGElementInstance.h" +#include "SVGElementRareData.h" +#include "SVGNames.h" +#include "SVGSVGElement.h" +#include "SVGURIReference.h" +#include "SVGUseElement.h" +#include "ScriptEventListener.h" +#include "XMLNames.h" + +namespace WebCore { + +using namespace HTMLNames; + +SVGElement::SVGElement(const QualifiedName& tagName, Document* document) + : StyledElement(tagName, document, CreateSVGElementZeroRefCount) +{ +} + +PassRefPtr SVGElement::create(const QualifiedName& tagName, Document* document) +{ + return new SVGElement(tagName, document); +} + +SVGElement::~SVGElement() +{ + if (!hasRareSVGData()) + ASSERT(!SVGElementRareData::rareDataMap().contains(this)); + else { + SVGElementRareData::SVGElementRareDataMap& rareDataMap = SVGElementRareData::rareDataMap(); + SVGElementRareData::SVGElementRareDataMap::iterator it = rareDataMap.find(this); + ASSERT(it != rareDataMap.end()); + + SVGElementRareData* rareData = it->second; + if (SVGCursorElement* cursorElement = rareData->cursorElement()) + cursorElement->removeClient(this); + if (CSSCursorImageValue* cursorImageValue = rareData->cursorImageValue()) + cursorImageValue->removeReferencedElement(this); + + delete rareData; + rareDataMap.remove(it); + } +} + +SVGElementRareData* SVGElement::rareSVGData() const +{ + ASSERT(hasRareSVGData()); + return SVGElementRareData::rareDataFromMap(this); +} + +SVGElementRareData* SVGElement::ensureRareSVGData() +{ + if (hasRareSVGData()) + return rareSVGData(); + + ASSERT(!SVGElementRareData::rareDataMap().contains(this)); + SVGElementRareData* data = new SVGElementRareData; + SVGElementRareData::rareDataMap().set(this, data); + setHasRareSVGData(); + return data; +} + +bool SVGElement::isSupported(StringImpl* feature, StringImpl* version) const +{ + return DOMImplementation::hasFeature(feature, version); +} + +String SVGElement::xmlbase() const +{ + return getAttribute(XMLNames::baseAttr); +} + +void SVGElement::setXmlbase(const String& value, ExceptionCode&) +{ + setAttribute(XMLNames::baseAttr, value); +} + +SVGSVGElement* SVGElement::ownerSVGElement() const +{ + Node* n = isShadowNode() ? const_cast(this)->shadowParentNode() : parentNode(); + while (n) { + if (n->hasTagName(SVGNames::svgTag)) + return static_cast(n); + + n = n->isShadowNode() ? n->shadowParentNode() : n->parentNode(); + } + + return 0; +} + +SVGElement* SVGElement::viewportElement() const +{ + // This function needs shadow tree support - as RenderSVGContainer uses this function + // to determine the "overflow" property. on wouldn't work otherwhise. + Node* n = isShadowNode() ? const_cast(this)->shadowParentNode() : parentNode(); + while (n) { + if (n->hasTagName(SVGNames::svgTag) || n->hasTagName(SVGNames::imageTag) || n->hasTagName(SVGNames::symbolTag)) + return static_cast(n); + + n = n->isShadowNode() ? n->shadowParentNode() : n->parentNode(); + } + + return 0; +} + +SVGDocumentExtensions* SVGElement::accessDocumentSVGExtensions() const +{ + // This function is provided for use by SVGAnimatedProperty to avoid + // global inclusion of Document.h in SVG code. + return document() ? document()->accessSVGExtensions() : 0; +} + +void SVGElement::mapInstanceToElement(SVGElementInstance* instance) +{ + ASSERT(instance); + + HashSet& instances = ensureRareSVGData()->elementInstances(); + ASSERT(!instances.contains(instance)); + + instances.add(instance); +} + +void SVGElement::removeInstanceMapping(SVGElementInstance* instance) +{ + ASSERT(instance); + ASSERT(hasRareSVGData()); + + HashSet& instances = rareSVGData()->elementInstances(); + ASSERT(instances.contains(instance)); + + instances.remove(instance); +} + +const HashSet& SVGElement::instancesForElement() const +{ + if (!hasRareSVGData()) { + DEFINE_STATIC_LOCAL(HashSet, emptyInstances, ()); + return emptyInstances; + } + return rareSVGData()->elementInstances(); +} + +void SVGElement::setCursorElement(SVGCursorElement* cursorElement) +{ + ensureRareSVGData()->setCursorElement(cursorElement); +} + +void SVGElement::setCursorImageValue(CSSCursorImageValue* cursorImageValue) +{ + ensureRareSVGData()->setCursorImageValue(cursorImageValue); +} + +void SVGElement::parseMappedAttribute(Attribute* attr) +{ + // standard events + if (attr->name() == onloadAttr) + setAttributeEventListener(eventNames().loadEvent, createAttributeEventListener(this, attr)); + else if (attr->name() == onclickAttr) + setAttributeEventListener(eventNames().clickEvent, createAttributeEventListener(this, attr)); + else if (attr->name() == onmousedownAttr) + setAttributeEventListener(eventNames().mousedownEvent, createAttributeEventListener(this, attr)); + else if (attr->name() == onmousemoveAttr) + setAttributeEventListener(eventNames().mousemoveEvent, createAttributeEventListener(this, attr)); + else if (attr->name() == onmouseoutAttr) + setAttributeEventListener(eventNames().mouseoutEvent, createAttributeEventListener(this, attr)); + else if (attr->name() == onmouseoverAttr) + setAttributeEventListener(eventNames().mouseoverEvent, createAttributeEventListener(this, attr)); + else if (attr->name() == onmouseupAttr) + setAttributeEventListener(eventNames().mouseupEvent, createAttributeEventListener(this, attr)); + else if (attr->name() == SVGNames::onfocusinAttr) + setAttributeEventListener(eventNames().focusinEvent, createAttributeEventListener(this, attr)); + else if (attr->name() == SVGNames::onfocusoutAttr) + setAttributeEventListener(eventNames().focusoutEvent, createAttributeEventListener(this, attr)); + else if (attr->name() == SVGNames::onactivateAttr) + setAttributeEventListener(eventNames().DOMActivateEvent, createAttributeEventListener(this, attr)); + else + StyledElement::parseMappedAttribute(attr); +} + +bool SVGElement::haveLoadedRequiredResources() +{ + Node* child = firstChild(); + while (child) { + if (child->isSVGElement() && !static_cast(child)->haveLoadedRequiredResources()) + return false; + child = child->nextSibling(); + } + return true; +} + +static bool hasLoadListener(Node* node) +{ + if (node->hasEventListeners(eventNames().loadEvent)) + return true; + + for (node = node->parentNode(); node && node->isElementNode(); node = node->parentNode()) { + const EventListenerVector& entry = node->getEventListeners(eventNames().loadEvent); + for (size_t i = 0; i < entry.size(); ++i) { + if (entry[i].useCapture) + return true; + } + } + + return false; +} + +void SVGElement::sendSVGLoadEventIfPossible(bool sendParentLoadEvents) +{ + RefPtr currentTarget = this; + while (currentTarget && currentTarget->haveLoadedRequiredResources()) { + RefPtr parent; + if (sendParentLoadEvents) + parent = currentTarget->parentNode(); // save the next parent to dispatch too incase dispatching the event changes the tree + if (hasLoadListener(currentTarget.get())) { + RefPtr event = Event::create(eventNames().loadEvent, false, false); + event->setTarget(currentTarget); + currentTarget->dispatchGenericEvent(event.release()); + } + currentTarget = (parent && parent->isSVGElement()) ? static_pointer_cast(parent) : 0; + } +} + +void SVGElement::finishParsingChildren() +{ + StyledElement::finishParsingChildren(); + + // finishParsingChildren() is called when the close tag is reached for an element (e.g. ) + // we send SVGLoad events here if we can, otherwise they'll be sent when any required loads finish + sendSVGLoadEventIfPossible(); +} + +bool SVGElement::childShouldCreateRenderer(Node* child) const +{ + if (child->isSVGElement()) + return static_cast(child)->isValid(); + return false; +} + +void SVGElement::insertedIntoDocument() +{ + StyledElement::insertedIntoDocument(); + SVGDocumentExtensions* extensions = document()->accessSVGExtensions(); + + String resourceId = getIdAttribute(); + if (extensions->isPendingResource(resourceId)) { + OwnPtr > clients(extensions->removePendingResource(resourceId)); + if (clients->isEmpty()) + return; + + HashSet::const_iterator it = clients->begin(); + const HashSet::const_iterator end = clients->end(); + + for (; it != end; ++it) + (*it)->buildPendingResource(); + } +} + +void SVGElement::attributeChanged(Attribute* attr, bool preserveDecls) +{ + ASSERT(attr); + if (!attr) + return; + + StyledElement::attributeChanged(attr, preserveDecls); + + // When an animated SVG property changes through SVG DOM, svgAttributeChanged() is called, not attributeChanged(). + // Next time someone tries to access the XML attributes, the synchronization code starts. During that synchronization + // SVGAnimatedPropertySynchronizer may call NamedNodeMap::removeAttribute(), which in turn calls attributeChanged(). + // At this point we're not allowed to call svgAttributeChanged() again - it may lead to extra work being done, or crashes + // see bug https://bugs.webkit.org/show_bug.cgi?id=40994. + if (isSynchronizingSVGAttributes()) + return; + + svgAttributeChanged(attr->name()); +} + +void SVGElement::updateAnimatedSVGAttribute(const QualifiedName& name) const +{ + if (isSynchronizingSVGAttributes() || areSVGAttributesValid()) + return; + + setIsSynchronizingSVGAttributes(); + + const_cast(this)->synchronizeProperty(name); + if (name == anyQName()) + setAreSVGAttributesValid(); + + clearIsSynchronizingSVGAttributes(); +} + +ContainerNode* SVGElement::eventParentNode() +{ + if (Node* shadowParent = shadowParentNode()) { + ASSERT(shadowParent->isContainerNode()); + return static_cast(shadowParent); + } + return StyledElement::eventParentNode(); +} + +} + +#endif // ENABLE(SVG)