Range constructors should take a Document&.
[WebKit-https.git] / Source / WebCore / accessibility / atk / WebKitAccessibleHyperlink.cpp
1 /*
2  * Copyright (C) 2010, 2011, 2012 Igalia S.L.
3  * Copyright (C) 2013 Samsung Electronics
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 #include "WebKitAccessibleHyperlink.h"
23
24 #if HAVE(ACCESSIBILITY)
25
26 #include "AXObjectCache.h"
27 #include "AccessibilityObject.h"
28 #include "NotImplemented.h"
29 #include "Position.h"
30 #include "Range.h"
31 #include "RenderListMarker.h"
32 #include "RenderObject.h"
33 #include "TextIterator.h"
34 #include "WebKitAccessibleUtil.h"
35 #include "WebKitAccessibleWrapperAtk.h"
36 #include "htmlediting.h"
37 #include <wtf/text/CString.h>
38
39 #include <atk/atk.h>
40 #include <glib.h>
41
42 using namespace WebCore;
43
44 struct _WebKitAccessibleHyperlinkPrivate {
45     WebKitAccessible* hyperlinkImpl;
46
47     // We cache these values so we can return them as const values.
48     CString actionName;
49     CString actionKeyBinding;
50 };
51
52 #define WEBKIT_ACCESSIBLE_HYPERLINK_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), WEBKIT_TYPE_ACCESSIBLE_HYPERLINK, WebKitAccessibleHyperlinkPrivate))
53
54 enum {
55     PROP_0,
56
57     PROP_HYPERLINK_IMPL
58 };
59
60 static gpointer webkitAccessibleHyperlinkParentClass = 0;
61
62 static AccessibilityObject* core(WebKitAccessible* accessible)
63 {
64     if (!accessible || !WEBKIT_IS_ACCESSIBLE(accessible))
65         return 0;
66
67     return webkitAccessibleGetAccessibilityObject(accessible);
68 }
69
70 static AccessibilityObject* core(WebKitAccessibleHyperlink* link)
71 {
72     if (!link)
73         return 0;
74
75     return core(link->priv->hyperlinkImpl);
76 }
77
78 static AccessibilityObject* core(AtkHyperlink* link)
79 {
80     if (!WEBKIT_IS_ACCESSIBLE_HYPERLINK(link))
81         return 0;
82
83     return core(WEBKIT_ACCESSIBLE_HYPERLINK(link));
84 }
85
86 static AccessibilityObject* core(AtkAction* action)
87 {
88     return core(WEBKIT_ACCESSIBLE_HYPERLINK(action));
89 }
90
91
92 static gboolean webkitAccessibleHyperlinkActionDoAction(AtkAction* action, gint index)
93 {
94     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE_HYPERLINK(action), FALSE);
95     g_return_val_if_fail(WEBKIT_ACCESSIBLE_HYPERLINK(action)->priv->hyperlinkImpl, FALSE);
96     g_return_val_if_fail(!index, FALSE);
97     returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE_HYPERLINK(action)->priv->hyperlinkImpl, FALSE);
98
99     if (!ATK_IS_ACTION(WEBKIT_ACCESSIBLE_HYPERLINK(action)->priv->hyperlinkImpl))
100         return FALSE;
101
102     AccessibilityObject* coreObject = core(action);
103     if (!coreObject)
104         return FALSE;
105
106     return coreObject->performDefaultAction();
107 }
108
109 static gint webkitAccessibleHyperlinkActionGetNActions(AtkAction* action)
110 {
111     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE_HYPERLINK(action), 0);
112     g_return_val_if_fail(WEBKIT_ACCESSIBLE_HYPERLINK(action)->priv->hyperlinkImpl, 0);
113     returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE_HYPERLINK(action)->priv->hyperlinkImpl, 0);
114
115     if (!ATK_IS_ACTION(WEBKIT_ACCESSIBLE_HYPERLINK(action)->priv->hyperlinkImpl))
116         return 0;
117
118     return 1;
119 }
120
121 static const gchar* webkitAccessibleHyperlinkActionGetDescription(AtkAction* action, gint index)
122 {
123     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE_HYPERLINK(action), 0);
124     g_return_val_if_fail(WEBKIT_ACCESSIBLE_HYPERLINK(action)->priv->hyperlinkImpl, 0);
125     g_return_val_if_fail(!index, 0);
126     returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE_HYPERLINK(action)->priv->hyperlinkImpl, 0);
127
128     // TODO: Need a way to provide/localize action descriptions.
129     notImplemented();
130     return "";
131 }
132
133 static const gchar* webkitAccessibleHyperlinkActionGetKeybinding(AtkAction* action, gint index)
134 {
135     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE_HYPERLINK(action), 0);
136     g_return_val_if_fail(WEBKIT_ACCESSIBLE_HYPERLINK(action)->priv->hyperlinkImpl, 0);
137     g_return_val_if_fail(!index, 0);
138
139     WebKitAccessibleHyperlinkPrivate* priv = WEBKIT_ACCESSIBLE_HYPERLINK(action)->priv;
140     returnValIfWebKitAccessibleIsInvalid(priv->hyperlinkImpl, 0);
141
142     if (!ATK_IS_ACTION(priv->hyperlinkImpl))
143         return 0;
144
145     AccessibilityObject* coreObject = core(action);
146     if (!coreObject)
147         return 0;
148
149     priv->actionKeyBinding = coreObject->accessKey().string().utf8();
150     return priv->actionKeyBinding.data();
151 }
152
153 static const gchar* webkitAccessibleHyperlinkActionGetName(AtkAction* action, gint index)
154 {
155     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE_HYPERLINK(action), 0);
156     g_return_val_if_fail(WEBKIT_ACCESSIBLE_HYPERLINK(action)->priv->hyperlinkImpl, 0);
157     g_return_val_if_fail(!index, 0);
158
159     WebKitAccessibleHyperlinkPrivate* priv = WEBKIT_ACCESSIBLE_HYPERLINK(action)->priv;
160     returnValIfWebKitAccessibleIsInvalid(priv->hyperlinkImpl, 0);
161
162     if (!ATK_IS_ACTION(priv->hyperlinkImpl))
163         return 0;
164
165     AccessibilityObject* coreObject = core(action);
166     if (!coreObject)
167         return 0;
168
169     priv->actionName = coreObject->actionVerb().utf8();
170     return priv->actionName.data();
171 }
172
173 static void atkActionInterfaceInit(AtkActionIface* iface)
174 {
175     iface->do_action = webkitAccessibleHyperlinkActionDoAction;
176     iface->get_n_actions = webkitAccessibleHyperlinkActionGetNActions;
177     iface->get_description = webkitAccessibleHyperlinkActionGetDescription;
178     iface->get_keybinding = webkitAccessibleHyperlinkActionGetKeybinding;
179     iface->get_name = webkitAccessibleHyperlinkActionGetName;
180 }
181
182 static gchar* webkitAccessibleHyperlinkGetURI(AtkHyperlink* link, gint index)
183 {
184     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE_HYPERLINK(link), 0);
185     g_return_val_if_fail(WEBKIT_ACCESSIBLE_HYPERLINK(link)->priv->hyperlinkImpl, 0);
186
187     // FIXME: Do NOT support more than one instance of an AtkObject
188     // implementing AtkHyperlinkImpl in every instance of AtkHyperLink
189     g_return_val_if_fail(!index, 0);
190
191     returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE_HYPERLINK(link)->priv->hyperlinkImpl, 0);
192
193     AccessibilityObject* coreObject = core(link);
194     if (!coreObject || coreObject->url().isNull())
195         return 0;
196
197     return g_strdup(coreObject->url().string().utf8().data());
198 }
199
200 static AtkObject* webkitAccessibleHyperlinkGetObject(AtkHyperlink* link, gint index)
201 {
202     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE_HYPERLINK(link), 0);
203     g_return_val_if_fail(WEBKIT_ACCESSIBLE_HYPERLINK(link)->priv->hyperlinkImpl, 0);
204
205     // FIXME: Do NOT support more than one instance of an AtkObject
206     // implementing AtkHyperlinkImpl in every instance of AtkHyperLink
207     g_return_val_if_fail(!index, 0);
208
209     returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE_HYPERLINK(link)->priv->hyperlinkImpl, 0);
210
211     return ATK_OBJECT(WEBKIT_ACCESSIBLE_HYPERLINK(link)->priv->hyperlinkImpl);
212 }
213
214 static gint getRangeLengthForObject(AccessibilityObject* obj, Range* range)
215 {
216     // This is going to be the actual length in most of the cases
217     int baseLength = TextIterator::rangeLength(range, true);
218
219     // Check whether the current hyperlink belongs to a list item.
220     // If so, we need to consider the length of the item's marker
221     AccessibilityObject* parent = obj->parentObjectUnignored();
222     if (!parent || !parent->isAccessibilityRenderObject() || !parent->isListItem())
223         return baseLength;
224
225     // Even if we don't expose list markers to Assistive
226     // Technologies, we need to have a way to measure their length
227     // for those cases when it's needed to take it into account
228     // separately (as in getAccessibilityObjectForOffset)
229     AccessibilityObject* markerObj = parent->firstChild();
230     if (!markerObj)
231         return baseLength;
232
233     RenderObject* renderer = markerObj->renderer();
234     if (!renderer || !renderer->isListMarker())
235         return baseLength;
236
237     RenderListMarker& marker = toRenderListMarker(*renderer);
238     return baseLength + marker.text().length() + marker.suffix().length();
239 }
240
241 static gint webkitAccessibleHyperlinkGetStartIndex(AtkHyperlink* link)
242 {
243     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE_HYPERLINK(link), 0);
244     g_return_val_if_fail(WEBKIT_ACCESSIBLE_HYPERLINK(link)->priv->hyperlinkImpl, 0);
245     returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE_HYPERLINK(link)->priv->hyperlinkImpl, 0);
246
247     AccessibilityObject* coreObject = core(link);
248     if (!coreObject)
249         return 0;
250
251     AccessibilityObject* parentUnignored = coreObject->parentObjectUnignored();
252     if (!parentUnignored)
253         return 0;
254
255     Node* node = coreObject->node();
256     if (!node)
257         return 0;
258
259     Node* parentNode = parentUnignored->node();
260     if (!parentNode)
261         return 0;
262
263     RefPtr<Range> range = Range::create(node->document(), firstPositionInOrBeforeNode(parentNode), firstPositionInOrBeforeNode(node));
264     return getRangeLengthForObject(coreObject, range.get());
265 }
266
267 static gint webkitAccessibleHyperlinkGetEndIndex(AtkHyperlink* link)
268 {
269     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE_HYPERLINK(link), 0);
270     g_return_val_if_fail(WEBKIT_ACCESSIBLE_HYPERLINK(link)->priv->hyperlinkImpl, 0);
271     returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE_HYPERLINK(link)->priv->hyperlinkImpl, 0);
272
273     AccessibilityObject* coreObject = core(link);
274     if (!coreObject)
275         return 0;
276
277     AccessibilityObject* parentUnignored = coreObject->parentObjectUnignored();
278     if (!parentUnignored)
279         return 0;
280
281     Node* node = coreObject->node();
282     if (!node)
283         return 0;
284
285     Node* parentNode = parentUnignored->node();
286     if (!parentNode)
287         return 0;
288
289     RefPtr<Range> range = Range::create(node->document(), firstPositionInOrBeforeNode(parentNode), lastPositionInOrAfterNode(node));
290     return getRangeLengthForObject(coreObject, range.get());
291 }
292
293 static gboolean webkitAccessibleHyperlinkIsValid(AtkHyperlink* link)
294 {
295     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE_HYPERLINK(link), FALSE);
296     g_return_val_if_fail(WEBKIT_ACCESSIBLE_HYPERLINK(link)->priv->hyperlinkImpl, FALSE);
297     returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE_HYPERLINK(link)->priv->hyperlinkImpl, FALSE);
298
299     // Link is valid for the whole object's lifetime
300     return TRUE;
301 }
302
303 static gint webkitAccessibleHyperlinkGetNAnchors(AtkHyperlink* link)
304 {
305     // FIXME Do NOT support more than one instance of an AtkObject
306     // implementing AtkHyperlinkImpl in every instance of AtkHyperLink
307     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE_HYPERLINK(link), 0);
308     g_return_val_if_fail(WEBKIT_ACCESSIBLE_HYPERLINK(link)->priv->hyperlinkImpl, 0);
309     returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE_HYPERLINK(link)->priv->hyperlinkImpl, 0);
310
311     return 1;
312 }
313
314 static gboolean webkitAccessibleHyperlinkIsSelectedLink(AtkHyperlink* link)
315 {
316     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE_HYPERLINK(link), FALSE);
317     g_return_val_if_fail(WEBKIT_ACCESSIBLE_HYPERLINK(link)->priv->hyperlinkImpl, FALSE);
318     returnValIfWebKitAccessibleIsInvalid(WEBKIT_ACCESSIBLE_HYPERLINK(link)->priv->hyperlinkImpl, FALSE);
319
320     // Not implemented: this function is deprecated in ATK now
321     notImplemented();
322     return FALSE;
323 }
324
325 static void webkitAccessibleHyperlinkGetProperty(GObject* object, guint propId, GValue* value, GParamSpec* pspec)
326 {
327     switch (propId) {
328     case PROP_HYPERLINK_IMPL:
329         g_value_set_object(value, WEBKIT_ACCESSIBLE_HYPERLINK(object)->priv->hyperlinkImpl);
330         break;
331     default:
332         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propId, pspec);
333     }
334 }
335
336 static void webkitAccessibleHyperlinkSetProperty(GObject* object, guint propId, const GValue* value, GParamSpec* pspec)
337 {
338     WebKitAccessibleHyperlinkPrivate* priv = WEBKIT_ACCESSIBLE_HYPERLINK(object)->priv;
339
340     switch (propId) {
341     case PROP_HYPERLINK_IMPL:
342         // No need to check and unref previous values of
343         // priv->hyperlinkImpl as this is a CONSTRUCT ONLY property
344         priv->hyperlinkImpl = WEBKIT_ACCESSIBLE(g_value_get_object(value));
345         g_object_weak_ref(G_OBJECT(priv->hyperlinkImpl), (GWeakNotify)g_object_unref, object);
346         break;
347     default:
348         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propId, pspec);
349     }
350 }
351
352 static void webkitAccessibleHyperlinkFinalize(GObject* object)
353 {
354     G_OBJECT_CLASS(webkitAccessibleHyperlinkParentClass)->finalize(object);
355 }
356
357 static void webkitAccessibleHyperlinkClassInit(AtkHyperlinkClass* klass)
358 {
359     GObjectClass* gobjectClass = G_OBJECT_CLASS(klass);
360
361     webkitAccessibleHyperlinkParentClass = g_type_class_peek_parent(klass);
362
363     gobjectClass->finalize = webkitAccessibleHyperlinkFinalize;
364     gobjectClass->set_property = webkitAccessibleHyperlinkSetProperty;
365     gobjectClass->get_property = webkitAccessibleHyperlinkGetProperty;
366
367     klass->get_uri = webkitAccessibleHyperlinkGetURI;
368     klass->get_object = webkitAccessibleHyperlinkGetObject;
369     klass->get_start_index = webkitAccessibleHyperlinkGetStartIndex;
370     klass->get_end_index = webkitAccessibleHyperlinkGetEndIndex;
371     klass->is_valid = webkitAccessibleHyperlinkIsValid;
372     klass->get_n_anchors = webkitAccessibleHyperlinkGetNAnchors;
373     klass->is_selected_link = webkitAccessibleHyperlinkIsSelectedLink;
374
375     g_object_class_install_property(gobjectClass, PROP_HYPERLINK_IMPL,
376         g_param_spec_object("hyperlink-impl",
377             "Hyperlink implementation",
378             "The associated WebKitAccessible instance.",
379             WEBKIT_TYPE_ACCESSIBLE,
380             (GParamFlags)(G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS)));
381
382     g_type_class_add_private(gobjectClass, sizeof(WebKitAccessibleHyperlinkPrivate));
383 }
384
385 static void webkitAccessibleHyperlinkInit(AtkHyperlink* link)
386 {
387     WEBKIT_ACCESSIBLE_HYPERLINK(link)->priv = WEBKIT_ACCESSIBLE_HYPERLINK_GET_PRIVATE(link);
388     WEBKIT_ACCESSIBLE_HYPERLINK(link)->priv->hyperlinkImpl = 0;
389 }
390
391 GType webkitAccessibleHyperlinkGetType()
392 {
393     static volatile gsize typeVolatile = 0;
394
395     if (g_once_init_enter(&typeVolatile)) {
396         static const GTypeInfo tinfo = {
397             sizeof(WebKitAccessibleHyperlinkClass),
398             (GBaseInitFunc) 0,
399             (GBaseFinalizeFunc) 0,
400             (GClassInitFunc) webkitAccessibleHyperlinkClassInit,
401             (GClassFinalizeFunc) 0,
402             0, /* class data */
403             sizeof(WebKitAccessibleHyperlink), /* instance size */
404             0, /* nb preallocs */
405             (GInstanceInitFunc) webkitAccessibleHyperlinkInit,
406             0 /* value table */
407         };
408
409         static const GInterfaceInfo actionInfo = {
410             (GInterfaceInitFunc)(GInterfaceInitFunc)atkActionInterfaceInit,
411             (GInterfaceFinalizeFunc) 0, 0
412         };
413
414         GType type = g_type_register_static(ATK_TYPE_HYPERLINK, "WebKitAccessibleHyperlink", &tinfo, GTypeFlags(0));
415         g_type_add_interface_static(type, ATK_TYPE_ACTION, &actionInfo);
416
417         g_once_init_leave(&typeVolatile, type);
418     }
419
420     return typeVolatile;
421 }
422
423 WebKitAccessibleHyperlink* webkitAccessibleHyperlinkNew(AtkHyperlinkImpl* hyperlinkImpl)
424 {
425     g_return_val_if_fail(ATK_IS_HYPERLINK_IMPL(hyperlinkImpl), 0);
426     return WEBKIT_ACCESSIBLE_HYPERLINK(g_object_new(WEBKIT_TYPE_ACCESSIBLE_HYPERLINK, "hyperlink-impl", hyperlinkImpl, 0));
427 }
428
429 WebCore::AccessibilityObject* webkitAccessibleHyperlinkGetAccessibilityObject(WebKitAccessibleHyperlink* link)
430 {
431     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE_HYPERLINK(link), 0);
432     return core(link);
433 }
434
435 #endif // HAVE(ACCESSIBILITY)