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)