4b3a5290ce6d6a870067717f52d4acb4ad45fdb6
[WebKit-https.git] / Source / WebCore / html / HTMLAreaElement.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  * Copyright (C) 2004, 2005, 2006, 2009, 2011 Apple Inc. All rights reserved.
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Library General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Library General Public License for more details.
15  *
16  * You should have received a copy of the GNU Library General Public License
17  * along with this library; see the file COPYING.LIB.  If not, write to
18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  * Boston, MA 02110-1301, USA.
20  */
21
22 #include "config.h"
23 #include "HTMLAreaElement.h"
24
25 #include "AffineTransform.h"
26 #include "Frame.h"
27 #include "HTMLImageElement.h"
28 #include "HTMLMapElement.h"
29 #include "HitTestResult.h"
30 #include "Path.h"
31 #include "RenderImage.h"
32 #include "RenderView.h"
33
34 namespace WebCore {
35
36 using namespace HTMLNames;
37
38 inline HTMLAreaElement::HTMLAreaElement(const QualifiedName& tagName, Document& document)
39     : HTMLAnchorElement(tagName, document)
40     , m_coordsLen(0)
41     , m_lastSize(-1, -1)
42     , m_shape(Unknown)
43 {
44     ASSERT(hasTagName(areaTag));
45 }
46
47 Ref<HTMLAreaElement> HTMLAreaElement::create(const QualifiedName& tagName, Document& document)
48 {
49     return adoptRef(*new HTMLAreaElement(tagName, document));
50 }
51
52 void HTMLAreaElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
53 {
54     if (name == shapeAttr) {
55         if (equalLettersIgnoringASCIICase(value, "default"))
56             m_shape = Default;
57         else if (equalLettersIgnoringASCIICase(value, "circle"))
58             m_shape = Circle;
59         else if (equalLettersIgnoringASCIICase(value, "poly"))
60             m_shape = Poly;
61         else if (equalLettersIgnoringASCIICase(value, "rect"))
62             m_shape = Rect;
63         invalidateCachedRegion();
64     } else if (name == coordsAttr) {
65         m_coords = newCoordsArray(value.string(), m_coordsLen);
66         invalidateCachedRegion();
67     } else if (name == altAttr || name == accesskeyAttr) {
68         // Do nothing.
69     } else
70         HTMLAnchorElement::parseAttribute(name, value);
71 }
72
73 void HTMLAreaElement::invalidateCachedRegion()
74 {
75     m_lastSize = LayoutSize(-1, -1);
76 }
77
78 bool HTMLAreaElement::mapMouseEvent(LayoutPoint location, const LayoutSize& size, HitTestResult& result)
79 {
80     if (m_lastSize != size) {
81         m_region = std::make_unique<Path>(getRegion(size));
82         m_lastSize = size;
83     }
84
85     if (!m_region->contains(location))
86         return false;
87     
88     result.setInnerNode(this);
89     result.setURLElement(this);
90     return true;
91 }
92
93 // FIXME: We should use RenderElement* instead of RenderObject* once we upstream iOS's DOMUIKitExtensions.{h, mm}.
94 Path HTMLAreaElement::computePath(RenderObject* obj) const
95 {
96     if (!obj)
97         return Path();
98     
99     // FIXME: This doesn't work correctly with transforms.
100     FloatPoint absPos = obj->localToAbsolute();
101
102     // Default should default to the size of the containing object.
103     LayoutSize size = m_lastSize;
104     if (m_shape == Default)
105         size = obj->absoluteOutlineBounds().size();
106     
107     Path p = getRegion(size);
108     float zoomFactor = obj->style().effectiveZoom();
109     if (zoomFactor != 1.0f) {
110         AffineTransform zoomTransform;
111         zoomTransform.scale(zoomFactor);
112         p.transform(zoomTransform);
113     }
114
115     p.translate(toFloatSize(absPos));
116     return p;
117 }
118
119 Path HTMLAreaElement::computePathForFocusRing(const LayoutSize& elementSize) const
120 {
121     return getRegion(m_shape == Default ? elementSize : m_lastSize);
122 }
123
124 // FIXME: Use RenderElement* instead of RenderObject* once we upstream iOS's DOMUIKitExtensions.{h, mm}.
125 LayoutRect HTMLAreaElement::computeRect(RenderObject* obj) const
126 {
127     return enclosingLayoutRect(computePath(obj).fastBoundingRect());
128 }
129
130 Path HTMLAreaElement::getRegion(const LayoutSize& size) const
131 {
132     if (!m_coords && m_shape != Default)
133         return Path();
134
135     LayoutUnit width = size.width();
136     LayoutUnit height = size.height();
137
138     // If element omits the shape attribute, select shape based on number of coordinates.
139     Shape shape = m_shape;
140     if (shape == Unknown) {
141         if (m_coordsLen == 3)
142             shape = Circle;
143         else if (m_coordsLen == 4)
144             shape = Rect;
145         else if (m_coordsLen >= 6)
146             shape = Poly;
147     }
148
149     Path path;
150     switch (shape) {
151         case Poly:
152             if (m_coordsLen >= 6) {
153                 int numPoints = m_coordsLen / 2;
154                 path.moveTo(FloatPoint(minimumValueForLength(m_coords[0], width), minimumValueForLength(m_coords[1], height)));
155                 for (int i = 1; i < numPoints; ++i)
156                     path.addLineTo(FloatPoint(minimumValueForLength(m_coords[i * 2], width), minimumValueForLength(m_coords[i * 2 + 1], height)));
157                 path.closeSubpath();
158             }
159             break;
160         case Circle:
161             if (m_coordsLen >= 3) {
162                 Length radius = m_coords[2];
163                 int r = std::min(minimumValueForLength(radius, width), minimumValueForLength(radius, height));
164                 path.addEllipse(FloatRect(minimumValueForLength(m_coords[0], width) - r, minimumValueForLength(m_coords[1], height) - r, 2 * r, 2 * r));
165             }
166             break;
167         case Rect:
168             if (m_coordsLen >= 4) {
169                 int x0 = minimumValueForLength(m_coords[0], width);
170                 int y0 = minimumValueForLength(m_coords[1], height);
171                 int x1 = minimumValueForLength(m_coords[2], width);
172                 int y1 = minimumValueForLength(m_coords[3], height);
173                 path.addRect(FloatRect(x0, y0, x1 - x0, y1 - y0));
174             }
175             break;
176         case Default:
177             path.addRect(FloatRect(0, 0, width, height));
178             break;
179         case Unknown:
180             break;
181     }
182
183     return path;
184 }
185
186 HTMLImageElement* HTMLAreaElement::imageElement() const
187 {
188     Node* mapElement = parentNode();
189     if (!is<HTMLMapElement>(mapElement))
190         return nullptr;
191     
192     return downcast<HTMLMapElement>(*mapElement).imageElement();
193 }
194
195 bool HTMLAreaElement::isKeyboardFocusable(KeyboardEvent*) const
196 {
197     return isFocusable();
198 }
199     
200 bool HTMLAreaElement::isMouseFocusable() const
201 {
202     return isFocusable();
203 }
204
205 bool HTMLAreaElement::isFocusable() const
206 {
207     HTMLImageElement* image = imageElement();
208     if (!image || !image->renderer() || image->renderer()->style().visibility() != VISIBLE)
209         return false;
210
211     return supportsFocus() && Element::tabIndex() >= 0;
212 }
213     
214 void HTMLAreaElement::setFocus(bool shouldBeFocused)
215 {
216     if (focused() == shouldBeFocused)
217         return;
218
219     HTMLAnchorElement::setFocus(shouldBeFocused);
220
221     HTMLImageElement* imageElement = this->imageElement();
222     if (!imageElement)
223         return;
224
225     auto* renderer = imageElement->renderer();
226     if (!is<RenderImage>(renderer))
227         return;
228
229     downcast<RenderImage>(*renderer).areaElementFocusChanged(this);
230 }
231     
232 void HTMLAreaElement::updateFocusAppearance(SelectionRestorationMode restorationMode, SelectionRevealMode revealMode)
233 {
234     if (!isFocusable())
235         return;
236
237     HTMLImageElement* imageElement = this->imageElement();
238     if (!imageElement)
239         return;
240
241     imageElement->updateFocusAppearance(restorationMode, revealMode);
242 }
243     
244 bool HTMLAreaElement::supportsFocus() const
245 {
246     // If the AREA element was a link, it should support focus.
247     // The inherited method is not used because it assumes that a render object must exist 
248     // for the element to support focus. AREA elements do not have render objects.
249     return isLink();
250 }
251
252 String HTMLAreaElement::target() const
253 {
254     return attributeWithoutSynchronization(targetAttr);
255 }
256
257 }