jsDocumentPrototypeFunctionGetElementById should not create an AtomicString for the...
[WebKit-https.git] / Source / WebCore / svg / SVGAElement.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  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
5  * Copyright (C) 2010 Apple Inc. All rights reserved.
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public License
18  * along with this library; see the file COPYING.LIB.  If not, write to
19  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20  * Boston, MA 02110-1301, USA.
21  */
22
23 #include "config.h"
24 #include "SVGAElement.h"
25
26 #include "Attr.h"
27 #include "Attribute.h"
28 #include "Document.h"
29 #include "EventHandler.h"
30 #include "EventNames.h"
31 #include "Frame.h"
32 #include "FrameLoader.h"
33 #include "FrameLoaderTypes.h"
34 #include "HTMLAnchorElement.h"
35 #include "HTMLParserIdioms.h"
36 #include "KeyboardEvent.h"
37 #include "MouseEvent.h"
38 #include "PlatformMouseEvent.h"
39 #include "RenderSVGInline.h"
40 #include "RenderSVGText.h"
41 #include "RenderSVGTransformableContainer.h"
42 #include "ResourceRequest.h"
43 #include "SVGElementInstance.h"
44 #include "SVGNames.h"
45 #include "SVGSMILElement.h"
46 #include "XLinkNames.h"
47
48 namespace WebCore {
49
50 using namespace HTMLNames;
51
52 // Animated property definitions
53 DEFINE_ANIMATED_STRING(SVGAElement, SVGNames::targetAttr, SVGTarget, svgTarget)
54 DEFINE_ANIMATED_STRING(SVGAElement, XLinkNames::hrefAttr, Href, href)
55 DEFINE_ANIMATED_BOOLEAN(SVGAElement, SVGNames::externalResourcesRequiredAttr, ExternalResourcesRequired, externalResourcesRequired)
56
57 BEGIN_REGISTER_ANIMATED_PROPERTIES(SVGAElement)
58     REGISTER_LOCAL_ANIMATED_PROPERTY(svgTarget)
59     REGISTER_LOCAL_ANIMATED_PROPERTY(href)
60     REGISTER_LOCAL_ANIMATED_PROPERTY(externalResourcesRequired)
61     REGISTER_PARENT_ANIMATED_PROPERTIES(SVGGraphicsElement)
62 END_REGISTER_ANIMATED_PROPERTIES
63
64 inline SVGAElement::SVGAElement(const QualifiedName& tagName, Document& document)
65     : SVGGraphicsElement(tagName, document)
66 {
67     ASSERT(hasTagName(SVGNames::aTag));
68     registerAnimatedPropertiesForSVGAElement();
69 }
70
71 PassRefPtr<SVGAElement> SVGAElement::create(const QualifiedName& tagName, Document& document)
72 {
73     return adoptRef(new SVGAElement(tagName, document));
74 }
75
76 String SVGAElement::title() const
77 {
78     // If the xlink:title is set (non-empty string), use it.
79     const AtomicString& title = fastGetAttribute(XLinkNames::titleAttr);
80     if (!title.isEmpty())
81         return title;
82
83     // Otherwise, use the title of this element.
84     return SVGElement::title();
85 }
86
87 bool SVGAElement::isSupportedAttribute(const QualifiedName& attrName)
88 {
89     DEFINE_STATIC_LOCAL(HashSet<QualifiedName>, supportedAttributes, ());
90     if (supportedAttributes.isEmpty()) {
91         SVGURIReference::addSupportedAttributes(supportedAttributes);
92         SVGLangSpace::addSupportedAttributes(supportedAttributes);
93         SVGExternalResourcesRequired::addSupportedAttributes(supportedAttributes);
94         supportedAttributes.add(SVGNames::targetAttr);
95     }
96     return supportedAttributes.contains<SVGAttributeHashTranslator>(attrName);
97 }
98
99 void SVGAElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
100 {
101     if (!isSupportedAttribute(name)) {
102         SVGGraphicsElement::parseAttribute(name, value);
103         return;
104     }
105
106     if (name == SVGNames::targetAttr) {
107         setSVGTargetBaseValue(value);
108         return;
109     }
110
111     if (SVGURIReference::parseAttribute(name, value))
112         return;
113     if (SVGLangSpace::parseAttribute(name, value))
114         return;
115     if (SVGExternalResourcesRequired::parseAttribute(name, value))
116         return;
117
118     ASSERT_NOT_REACHED();
119 }
120
121 void SVGAElement::svgAttributeChanged(const QualifiedName& attrName)
122 {
123     if (!isSupportedAttribute(attrName)) {
124         SVGGraphicsElement::svgAttributeChanged(attrName);
125         return;
126     }
127
128     SVGElementInstance::InvalidationGuard invalidationGuard(this);
129
130     // Unlike other SVG*Element classes, SVGAElement only listens to SVGURIReference changes
131     // as none of the other properties changes the linking behaviour for our <a> element.
132     if (SVGURIReference::isKnownAttribute(attrName)) {
133         bool wasLink = isLink();
134         setIsLink(!href().isNull() && !shouldProhibitLinks(this));
135         if (wasLink != isLink())
136             setNeedsStyleRecalc();
137     }
138 }
139
140 RenderPtr<RenderElement> SVGAElement::createElementRenderer(PassRef<RenderStyle> style)
141 {
142     if (parentNode() && parentNode()->isSVGElement() && toSVGElement(parentNode())->isTextContent())
143         return createRenderer<RenderSVGInline>(*this, std::move(style));
144
145     return createRenderer<RenderSVGTransformableContainer>(*this, std::move(style));
146 }
147
148 void SVGAElement::defaultEventHandler(Event* event)
149 {
150     if (isLink()) {
151         if (focused() && isEnterKeyKeydownEvent(event)) {
152             event->setDefaultHandled();
153             dispatchSimulatedClick(event);
154             return;
155         }
156
157         if (isLinkClick(event)) {
158             String url = stripLeadingAndTrailingHTMLSpaces(href());
159
160             if (url[0] == '#') {
161                 Element* targetElement = treeScope().getElementById(url.substringSharingImpl(1));
162                 if (targetElement && isSVGSMILElement(*targetElement)) {
163                     toSVGSMILElement(*targetElement).beginByLinkActivation();
164                     event->setDefaultHandled();
165                     return;
166                 }
167                 // Only allow navigation to internal <view> anchors.
168                 if (targetElement && !targetElement->hasTagName(SVGNames::viewTag))
169                     return;
170             }
171
172             String target = this->target();
173             if (target.isEmpty() && fastGetAttribute(XLinkNames::showAttr) == "new")
174                 target = "_blank";
175             event->setDefaultHandled();
176
177             Frame* frame = document().frame();
178             if (!frame)
179                 return;
180             frame->loader().urlSelected(document().completeURL(url), target, event, false, false, MaybeSendReferrer);
181             return;
182         }
183     }
184
185     SVGGraphicsElement::defaultEventHandler(event);
186 }
187
188 bool SVGAElement::supportsFocus() const
189 {
190     if (hasEditableStyle())
191         return SVGGraphicsElement::supportsFocus();
192     return true;
193 }
194
195 bool SVGAElement::isFocusable() const
196 {
197     if (renderer() && renderer()->absoluteClippedOverflowRect().isEmpty())
198         return false;
199     
200     return SVGElement::isFocusable();
201 }
202
203 bool SVGAElement::isURLAttribute(const Attribute& attribute) const
204 {
205     return attribute.name().localName() == hrefAttr || SVGGraphicsElement::isURLAttribute(attribute);
206 }
207
208 bool SVGAElement::isMouseFocusable() const
209 {
210     return false;
211 }
212
213 bool SVGAElement::isKeyboardFocusable(KeyboardEvent* event) const
214 {
215     if (!isFocusable())
216         return false;
217     
218     if (!document().frame())
219         return false;
220     
221     return document().frame()->eventHandler().tabsToLinks(event);
222 }
223
224 bool SVGAElement::childShouldCreateRenderer(const Node& child) const
225 {
226     // http://www.w3.org/2003/01/REC-SVG11-20030114-errata#linking-text-environment
227     // The 'a' element may contain any element that its parent may contain, except itself.
228     if (child.hasTagName(SVGNames::aTag))
229         return false;
230     if (parentNode() && parentNode()->isSVGElement())
231         return parentNode()->childShouldCreateRenderer(child);
232
233     return SVGElement::childShouldCreateRenderer(child);
234 }
235
236 bool SVGAElement::willRespondToMouseClickEvents()
237
238     return isLink() || SVGGraphicsElement::willRespondToMouseClickEvents(); 
239 }
240
241 } // namespace WebCore