WebCore/svg/SVGScriptElement.cpp

   1 /*
   2     Copyright (C) 2004, 2005, 2008 Nikolas Zimmermann <zimmermann@kde.org>
   3                   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 "Document.h"
  27 #include "Event.h"
  28 #include "EventNames.h"
  29 #include "MappedAttribute.h"
  30 #include "SVGNames.h"
  31
  32 namespace WebCore {
  33
  34 SVGScriptElement::SVGScriptElement(const QualifiedName& tagName, Document* doc, bool createdByParser)
  35     : SVGElement(tagName, doc)
  36     , SVGURIReference()
  37     , SVGExternalResourcesRequired()
  38     , m_href(this, XLinkNames::hrefAttr)
  39     , m_externalResourcesRequired(this, SVGNames::externalResourcesRequiredAttr, false)
  40     , m_data(this, this)
  41 {
  42     m_data.setCreatedByParser(createdByParser);
  43 }
  44
  45 SVGScriptElement::~SVGScriptElement()
  46 {
  47 }
  48
  49 String SVGScriptElement::scriptContent() const
  50 {
  51     return m_data.scriptContent();
  52 }
  53
  54 void SVGScriptElement::parseMappedAttribute(MappedAttribute* attr)
  55 {
  56     const QualifiedName& attrName = attr->name();
  57
  58     if (attrName == SVGNames::typeAttr)
  59         setType(attr->value());
  60     else {
  61         if (SVGURIReference::parseMappedAttribute(attr))
  62             return;
  63         if (SVGExternalResourcesRequired::parseMappedAttribute(attr))
  64             return;
  65
  66         SVGElement::parseMappedAttribute(attr);
  67     }
  68 }
  69
  70 void SVGScriptElement::svgAttributeChanged(const QualifiedName& attrName)
  71 {
  72     SVGElement::svgAttributeChanged(attrName);
  73
  74     if (SVGURIReference::isKnownAttribute(attrName))
  75         handleSourceAttribute(m_data, href());
  76     else if (SVGExternalResourcesRequired::isKnownAttribute(attrName)) {
  77         // Handle dynamic updates of the 'externalResourcesRequired' attribute. Only possible case: changing from 'true' to 'false'
  78         // causes an immediate dispatch of the SVGLoad event. If the attribute value was 'false' before inserting the script element
  79         // in the document, the SVGLoad event has already been dispatched.
  80         if (!externalResourcesRequiredBaseValue() && !m_data.haveFiredLoadEvent() && !m_data.createdByParser()) {
  81             m_data.setHaveFiredLoadEvent(true);
  82             ASSERT(haveLoadedRequiredResources());
  83
  84             sendSVGLoadEventIfPossible();
  85         }
  86     }
  87 }
  88
  89 void SVGScriptElement::insertedIntoDocument()
  90 {
  91     SVGElement::insertedIntoDocument();
  92     ScriptElement::insertedIntoDocument(m_data, sourceAttributeValue());
  93
  94     if (m_data.createdByParser())
  95         return;
  96
  97     // Eventually send SVGLoad event now for the dynamically inserted script element
  98     if (!externalResourcesRequiredBaseValue()) {
  99         m_data.setHaveFiredLoadEvent(true);
 100         sendSVGLoadEventIfPossible();
 101     }
 102 }
 103
 104 void SVGScriptElement::removedFromDocument()
 105 {
 106     SVGElement::removedFromDocument();
 107     ScriptElement::removedFromDocument(m_data);
 108 }
 109
 110 void SVGScriptElement::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)
 111 {
 112     ScriptElement::childrenChanged(m_data);
 113     SVGElement::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
 114 }
 115
 116 bool SVGScriptElement::isURLAttribute(Attribute* attr) const
 117 {
 118     return attr->name() == sourceAttributeValue();
 119 }
 120
 121 void SVGScriptElement::finishParsingChildren()
 122 {
 123     ScriptElement::finishParsingChildren(m_data, sourceAttributeValue());
 124     SVGElement::finishParsingChildren();
 125
 126     // A SVGLoad event has been fired by SVGElement::finishParsingChildren.
 127     if (!externalResourcesRequiredBaseValue())
 128         m_data.setHaveFiredLoadEvent(true);
 129 }
 130
 131 String SVGScriptElement::type() const
 132 {
 133     return m_type;
 134 }
 135
 136 void SVGScriptElement::setType(const String& type)
 137 {
 138     m_type = type;
 139 }
 140
 141 String SVGScriptElement::scriptCharset() const
 142 {
 143     return m_data.scriptCharset();
 144 }
 145
 146 void SVGScriptElement::addSubresourceAttributeURLs(ListHashSet<KURL>& urls) const
 147 {
 148     SVGElement::addSubresourceAttributeURLs(urls);
 149
 150     addSubresourceURL(urls, document()->completeURL(href()));
 151 }
 152
 153 bool SVGScriptElement::haveLoadedRequiredResources()
 154 {
 155     return !externalResourcesRequiredBaseValue() || m_data.haveFiredLoadEvent();
 156 }
 157
 158 String SVGScriptElement::sourceAttributeValue() const
 159 {
 160     return href();
 161 }
 162
 163 String SVGScriptElement::charsetAttributeValue() const
 164 {
 165     return String();
 166 }
 167
 168 String SVGScriptElement::typeAttributeValue() const
 169 {
 170     return type();
 171 }
 172
 173 String SVGScriptElement::languageAttributeValue() const
 174 {
 175     return String();
 176 }
 177
 178 String SVGScriptElement::forAttributeValue() const
 179 {
 180     return String();
 181 }
 182
 183 void SVGScriptElement::dispatchLoadEvent()
 184 {
 185     bool externalResourcesRequired = externalResourcesRequiredBaseValue();
 186
 187     if (m_data.createdByParser())
 188         ASSERT(externalResourcesRequired != m_data.haveFiredLoadEvent());
 189     else if (m_data.haveFiredLoadEvent()) {
 190         // If we've already fired an load event and externalResourcesRequired is set to 'true'
 191         // externalResourcesRequired has been modified while loading the <script>. Don't dispatch twice.
 192         if (externalResourcesRequired)
 193             return;
 194     }
 195
 196     // HTML and SVG differ completly in the 'onload' event handling of <script> elements.
 197     // HTML fires the 'load' event after it sucessfully loaded a remote resource, otherwhise an error event.
 198     // SVG fires the SVGLoad event immediately after parsing the <script> element, if externalResourcesRequired
 199     // is set to 'false', otherwhise it dispatches the 'SVGLoad' event just after loading the remote resource.
 200     if (externalResourcesRequired) {
 201         ASSERT(!m_data.haveFiredLoadEvent());
 202
 203         // Dispatch SVGLoad event
 204         m_data.setHaveFiredLoadEvent(true);
 205         ASSERT(haveLoadedRequiredResources());
 206
 207         sendSVGLoadEventIfPossible();
 208     }
 209 }
 210
 211 void SVGScriptElement::dispatchErrorEvent()
 212 {
 213     dispatchEvent(Event::create(eventNames().errorEvent, true, false));
 214 }
 215
 216 }
 217
 218 #endif // ENABLE(SVG)