e0931e68709fa70165b7d998fe9428a9f6b9cdde
[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 "Attribute.h"
27 #include "Frame.h"
28 #include "HTMLImageElement.h"
29 #include "HTMLMapElement.h"
30 #include "HitTestResult.h"
31 #include "Path.h"
32 #include "RenderImage.h"
33 #include "RenderView.h"
34
35 namespace WebCore {
36
37 using namespace HTMLNames;
38
39 inline HTMLAreaElement::HTMLAreaElement(const QualifiedName& tagName, Document& document)
40     : HTMLAnchorElement(tagName, document)
41     , m_coordsLen(0)
42     , m_lastSize(-1, -1)
43     , m_shape(Unknown)
44 {
45     ASSERT(hasTagName(areaTag));
46 }
47
48 PassRefPtr<HTMLAreaElement> HTMLAreaElement::create(const QualifiedName& tagName, Document& document)
49 {
50     return adoptRef(new HTMLAreaElement(tagName, document));
51 }
52
53 void HTMLAreaElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
54 {
55     if (name == shapeAttr) {
56         if (equalIgnoringCase(value, "default"))
57             m_shape = Default;
58         else if (equalIgnoringCase(value, "circle"))
59             m_shape = Circle;
60         else if (equalIgnoringCase(value, "poly"))
61             m_shape = Poly;
62         else if (equalIgnoringCase(value, "rect"))
63             m_shape = Rect;
64         invalidateCachedRegion();
65     } else if (name == coordsAttr) {
66         m_coords = newCoordsArray(value.string(), m_coordsLen);
67         invalidateCachedRegion();
68     } else if (name == altAttr || name == accesskeyAttr) {
69         // Do nothing.
70     } else
71         HTMLAnchorElement::parseAttribute(name, value);
72 }
73
74 void HTMLAreaElement::invalidateCachedRegion()
75 {
76     m_lastSize = LayoutSize(-1, -1);
77 }
78
79 bool HTMLAreaElement::mapMouseEvent(LayoutPoint location, const LayoutSize& size, HitTestResult& result)
80 {
81     if (m_lastSize != size) {
82         m_region = adoptPtr(new Path(getRegion(size)));
83         m_lastSize = size;
84     }
85
86     if (!m_region->contains(location))
87         return false;
88     
89     result.setInnerNode(this);
90     result.setURLElement(this);
91     return true;
92 }
93
94 // FIXME: We should use RenderElement* instead of RenderObject* once we upstream iOS's DOMUIKitExtensions.{h, mm}.
95 Path HTMLAreaElement::computePath(RenderObject* obj) const
96 {
97     if (!obj)
98         return Path();
99     
100     // FIXME: This doesn't work correctly with transforms.
101     FloatPoint absPos = obj->localToAbsolute();
102
103     // Default should default to the size of the containing object.
104     LayoutSize size = m_lastSize;
105     if (m_shape == Default)
106         size = obj->absoluteOutlineBounds().size();
107     
108     Path p = getRegion(size);
109     float zoomFactor = obj->style().effectiveZoom();
110     if (zoomFactor != 1.0f) {
111         AffineTransform zoomTransform;
112         zoomTransform.scale(zoomFactor);
113         p.transform(zoomTransform);
114     }
115
116     p.translate(toFloatSize(absPos));
117     return p;
118 }
119
120 // FIXME: Use RenderElement* instead of RenderObject* once we upstream iOS's DOMUIKitExtensions.{h, mm}.
121 LayoutRect HTMLAreaElement::computeRect(RenderObject* obj) const
122 {
123     return enclosingLayoutRect(computePath(obj).fastBoundingRect());
124 }
125
126 Path HTMLAreaElement::getRegion(const LayoutSize& size) const
127 {
128     if (!m_coords && m_shape != Default)
129         return Path();
130
131     LayoutUnit width = size.width();
132     LayoutUnit height = size.height();
133
134     // If element omits the shape attribute, select shape based on number of coordinates.
135     Shape shape = m_shape;
136     if (shape == Unknown) {
137         if (m_coordsLen == 3)
138             shape = Circle;
139         else if (m_coordsLen == 4)
140             shape = Rect;
141         else if (m_coordsLen >= 6)
142             shape = Poly;
143     }
144
145     Path path;
146     RenderView* renderView = document().renderView();
147     switch (shape) {
148         case Poly:
149             if (m_coordsLen >= 6) {
150                 int numPoints = m_coordsLen / 2;
151                 path.moveTo(FloatPoint(minimumValueForLength(m_coords[0], width, renderView), minimumValueForLength(m_coords[1], height, renderView)));
152                 for (int i = 1; i < numPoints; ++i)
153                     path.addLineTo(FloatPoint(minimumValueForLength(m_coords[i * 2], width, renderView), minimumValueForLength(m_coords[i * 2 + 1], height, renderView)));
154                 path.closeSubpath();
155             }
156             break;
157         case Circle:
158             if (m_coordsLen >= 3) {
159                 Length radius = m_coords[2];
160                 int r = std::min(minimumValueForLength(radius, width, renderView), minimumValueForLength(radius, height, renderView));
161                 path.addEllipse(FloatRect(minimumValueForLength(m_coords[0], width, renderView) - r, minimumValueForLength(m_coords[1], height, renderView) - r, 2 * r, 2 * r));
162             }
163             break;
164         case Rect:
165             if (m_coordsLen >= 4) {
166                 int x0 = minimumValueForLength(m_coords[0], width, renderView);
167                 int y0 = minimumValueForLength(m_coords[1], height, renderView);
168                 int x1 = minimumValueForLength(m_coords[2], width, renderView);
169                 int y1 = minimumValueForLength(m_coords[3], height, renderView);
170                 path.addRect(FloatRect(x0, y0, x1 - x0, y1 - y0));
171             }
172             break;
173         case Default:
174             path.addRect(FloatRect(0, 0, width, height));
175             break;
176         case Unknown:
177             break;
178     }
179
180     return path;
181 }
182
183 HTMLImageElement* HTMLAreaElement::imageElement() const
184 {
185     Node* mapElement = parentNode();
186     if (!mapElement || !isHTMLMapElement(mapElement))
187         return 0;
188     
189     return toHTMLMapElement(mapElement)->imageElement();
190 }
191
192 bool HTMLAreaElement::isKeyboardFocusable(KeyboardEvent*) const
193 {
194     return isFocusable();
195 }
196     
197 bool HTMLAreaElement::isMouseFocusable() const
198 {
199     return isFocusable();
200 }
201
202 bool HTMLAreaElement::isFocusable() const
203 {
204     HTMLImageElement* image = imageElement();
205     if (!image || !image->renderer() || image->renderer()->style().visibility() != VISIBLE)
206         return false;
207
208     return supportsFocus() && Element::tabIndex() >= 0;
209 }
210     
211 void HTMLAreaElement::setFocus(bool shouldBeFocused)
212 {
213     if (focused() == shouldBeFocused)
214         return;
215
216     HTMLAnchorElement::setFocus(shouldBeFocused);
217
218     HTMLImageElement* imageElement = this->imageElement();
219     if (!imageElement)
220         return;
221
222     auto renderer = imageElement->renderer();
223     if (!renderer || !renderer->isImage())
224         return;
225
226     toRenderImage(renderer)->areaElementFocusChanged(this);
227 }
228     
229 void HTMLAreaElement::updateFocusAppearance(bool restorePreviousSelection)
230 {
231     if (!isFocusable())
232         return;
233
234     HTMLImageElement* imageElement = this->imageElement();
235     if (!imageElement)
236         return;
237
238     imageElement->updateFocusAppearance(restorePreviousSelection);
239 }
240     
241 bool HTMLAreaElement::supportsFocus() const
242 {
243     // If the AREA element was a link, it should support focus.
244     // The inherited method is not used because it assumes that a render object must exist 
245     // for the element to support focus. AREA elements do not have render objects.
246     return isLink();
247 }
248
249 String HTMLAreaElement::target() const
250 {
251     return getAttribute(targetAttr);
252 }
253
254 }