Source/WebCore/svg/SVGScriptElement.cpp

   1 /*
   2  * Copyright (C) 2004, 2005, 2008 Nikolas Zimmermann <zimmermann@kde.org>
   3  * Copyright (C) 2004, 2005, 2007 Rob Buis <buis@kde.org>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public License
  16  * along with this library; see the file COPYING.LIB.  If not, write to
  17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18  * Boston, MA 02110-1301, USA.
  19  */
  20
  21 #include "config.h"
  22
  23 #if ENABLE(SVG)
  24 #include "SVGScriptElement.h"
  25
  26 #include "Attribute.h"
  27 #include "Document.h"
  28 #include "Event.h"
  29 #include "EventNames.h"
  30 #include "SVGNames.h"
  31
  32 namespace WebCore {
  33
  34 // Animated property definitions
  35 DEFINE_ANIMATED_STRING(SVGScriptElement, XLinkNames::hrefAttr, Href, href)
  36 DEFINE_ANIMATED_BOOLEAN(SVGScriptElement, SVGNames::externalResourcesRequiredAttr, ExternalResourcesRequired, externalResourcesRequired)
  37
  38 inline SVGScriptElement::SVGScriptElement(const QualifiedName& tagName, Document* document, bool wasInsertedByParser, bool wasAlreadyStarted)
  39     : SVGElement(tagName, document)
  40     , ScriptElement(this, wasInsertedByParser, wasAlreadyStarted)
  41 {
  42 }
  43
  44 PassRefPtr<SVGScriptElement> SVGScriptElement::create(const QualifiedName& tagName, Document* document, bool insertedByParser)
  45 {
  46     return adoptRef(new SVGScriptElement(tagName, document, insertedByParser, false));
  47 }
  48
  49 void SVGScriptElement::parseMappedAttribute(Attribute* attr)
  50 {
  51     const QualifiedName& attrName = attr->name();
  52
  53     if (attrName == SVGNames::typeAttr)
  54         setType(attr->value());
  55     else {
  56         if (SVGURIReference::parseMappedAttribute(attr))
  57             return;
  58         if (SVGExternalResourcesRequired::parseMappedAttribute(attr))
  59             return;
  60
  61         SVGElement::parseMappedAttribute(attr);
  62     }
  63 }
  64
  65 void SVGScriptElement::svgAttributeChanged(const QualifiedName& attrName)
  66 {
  67     SVGElement::svgAttributeChanged(attrName);
  68
  69     if (SVGURIReference::isKnownAttribute(attrName))
  70         handleSourceAttribute(href());
  71     else if (SVGExternalResourcesRequired::isKnownAttribute(attrName)) {
  72         // Handle dynamic updates of the 'externalResourcesRequired' attribute. Only possible case: changing from 'true' to 'false'
  73         // causes an immediate dispatch of the SVGLoad event. If the attribute value was 'false' before inserting the script element
  74         // in the document, the SVGLoad event has already been dispatched.
  75         if (!externalResourcesRequiredBaseValue() && !haveFiredLoadEvent() && !wasInsertedByParser()) {
  76             setHaveFiredLoadEvent(true);
  77             ASSERT(haveLoadedRequiredResources());
  78
  79             sendSVGLoadEventIfPossible();
  80         }
  81     }
  82 }
  83
  84 void SVGScriptElement::synchronizeProperty(const QualifiedName& attrName)
  85 {
  86     SVGElement::synchronizeProperty(attrName);
  87
  88     if (attrName == anyQName()) {
  89         synchronizeExternalResourcesRequired();
  90         synchronizeHref();
  91         return;
  92     }
  93
  94     if (SVGExternalResourcesRequired::isKnownAttribute(attrName))
  95         synchronizeExternalResourcesRequired();
  96     else if (SVGURIReference::isKnownAttribute(attrName))
  97         synchronizeHref();
  98 }
  99
 100 void SVGScriptElement::insertedIntoDocument()
 101 {
 102     SVGElement::insertedIntoDocument();
 103     ScriptElement::insertedIntoDocument(sourceAttributeValue());
 104
 105     if (wasInsertedByParser())
 106         return;
 107
 108     // Eventually send SVGLoad event now for the dynamically inserted script element
 109     if (!externalResourcesRequiredBaseValue()) {
 110         setHaveFiredLoadEvent(true);
 111         sendSVGLoadEventIfPossible();
 112     }
 113 }
 114
 115 void SVGScriptElement::removedFromDocument()
 116 {
 117     SVGElement::removedFromDocument();
 118     ScriptElement::removedFromDocument();
 119 }
 120
 121 void SVGScriptElement::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)
 122 {
 123     ScriptElement::childrenChanged();
 124     SVGElement::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
 125 }
 126
 127 bool SVGScriptElement::isURLAttribute(Attribute* attr) const
 128 {
 129     return attr->name() == sourceAttributeValue();
 130 }
 131
 132 void SVGScriptElement::finishParsingChildren()
 133 {
 134     ScriptElement::finishParsingChildren(sourceAttributeValue());
 135     SVGElement::finishParsingChildren();
 136
 137     // A SVGLoad event has been fired by SVGElement::finishParsingChildren.
 138     if (!externalResourcesRequiredBaseValue())
 139         setHaveFiredLoadEvent(true);
 140 }
 141
 142 String SVGScriptElement::type() const
 143 {
 144     return m_type;
 145 }
 146
 147 void SVGScriptElement::setType(const String& type)
 148 {
 149     m_type = type;
 150 }
 151
 152 void SVGScriptElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const
 153 {
 154     SVGElement::addSubresourceAttributeURLs(urls);
 155
 156     addSubresourceURL(urls, document()->completeURL(href()));
 157 }
 158
 159 bool SVGScriptElement::haveLoadedRequiredResources()
 160 {
 161     return !externalResourcesRequiredBaseValue() || haveFiredLoadEvent();
 162 }
 163
 164 String SVGScriptElement::sourceAttributeValue() const
 165 {
 166     return href();
 167 }
 168
 169 String SVGScriptElement::charsetAttributeValue() const
 170 {
 171     return String();
 172 }
 173
 174 String SVGScriptElement::typeAttributeValue() const
 175 {
 176     return type();
 177 }
 178
 179 String SVGScriptElement::languageAttributeValue() const
 180 {
 181     return String();
 182 }
 183
 184 String SVGScriptElement::forAttributeValue() const
 185 {
 186     return String();
 187 }
 188
 189 String SVGScriptElement::eventAttributeValue() const
 190 {
 191     return String();
 192 }
 193
 194 bool SVGScriptElement::asyncAttributeValue() const
 195 {
 196     return false;
 197 }
 198
 199 bool SVGScriptElement::deferAttributeValue() const
 200 {
 201     return false;
 202 }
 203
 204 void SVGScriptElement::dispatchLoadEvent()
 205 {
 206     bool externalResourcesRequired = externalResourcesRequiredBaseValue();
 207
 208     if (wasInsertedByParser())
 209         ASSERT(externalResourcesRequired != haveFiredLoadEvent());
 210     else if (haveFiredLoadEvent()) {
 211         // If we've already fired an load event and externalResourcesRequired is set to 'true'
 212         // externalResourcesRequired has been modified while loading the <script>. Don't dispatch twice.
 213         if (externalResourcesRequired)
 214             return;
 215     }
 216
 217     // HTML and SVG differ completly in the 'onload' event handling of <script> elements.
 218     // HTML fires the 'load' event after it sucessfully loaded a remote resource, otherwhise an error event.
 219     // SVG fires the SVGLoad event immediately after parsing the <script> element, if externalResourcesRequired
 220     // is set to 'false', otherwhise it dispatches the 'SVGLoad' event just after loading the remote resource.
 221     if (externalResourcesRequired) {
 222         ASSERT(!haveFiredLoadEvent());
 223
 224         // Dispatch SVGLoad event
 225         setHaveFiredLoadEvent(true);
 226         ASSERT(haveLoadedRequiredResources());
 227
 228         sendSVGLoadEventIfPossible();
 229     }
 230 }
 231
 232 void SVGScriptElement::dispatchErrorEvent()
 233 {
 234     dispatchEvent(Event::create(eventNames().errorEvent, true, false));
 235 }
 236
 237 PassRefPtr<Element> SVGScriptElement::cloneElementWithoutAttributesAndChildren() const
 238 {
 239     return adoptRef(new SVGScriptElement(tagQName(), document(), false, wasAlreadyStarted()));
 240 }
 241
 242 }
 243
 244 #endif // ENABLE(SVG)