code.vuplus.com Git - vuplus_webkit/blob - Source/WebCore/accessibility/gtk/WebKitAccessibleHyperlink.cpp

   1 /*
   2  * Copyright (C) 2010 Igalia S.L.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public License
  15  * along with this library; see the file COPYING.LIB.  If not, write to
  16  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17  * Boston, MA 02110-1301, USA.
  18  */
  19
  20 #include "config.h"
  21 #include "WebKitAccessibleHyperlink.h"
  22
  23 #if HAVE(ACCESSIBILITY)
  24
  25 #include "AXObjectCache.h"
  26 #include "AccessibilityObject.h"
  27 #include "AccessibilityObjectWrapperAtk.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 "htmlediting.h"
  35
  36 #include <atk/atk.h>
  37 #include <glib.h>
  38
  39 using namespace WebCore;
  40
  41 struct _WebKitAccessibleHyperlinkPrivate {
  42     WebKitAccessible* hyperlinkImpl;
  43 };
  44
  45 #define WEBKIT_ACCESSIBLE_HYPERLINK_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), WEBKIT_TYPE_ACCESSIBLE_HYPERLINK, WebKitAccessibleHyperlinkPrivate))
  46
  47 enum {
  48     PROP_0,
  49
  50     PROP_HYPERLINK_IMPL
  51 };
  52
  53 static gpointer webkitAccessibleHyperlinkParentClass = 0;
  54
  55 // Used to provide const char* returns.
  56 static const char* returnString(const String& str)
  57 {
  58     static CString returnedString;
  59     returnedString = str.utf8();
  60     return returnedString.data();
  61 }
  62
  63 static AccessibilityObject* core(WebKitAccessible* accessible)
  64 {
  65     if (!accessible || !WEBKIT_IS_ACCESSIBLE(accessible))
  66         return 0;
  67
  68     return webkit_accessible_get_accessibility_object(accessible);
  69 }
  70
  71 static AccessibilityObject* core(WebKitAccessibleHyperlink* link)
  72 {
  73     if (!link)
  74         return 0;
  75
  76     return core(link->priv->hyperlinkImpl);
  77 }
  78
  79 static AccessibilityObject* core(AtkHyperlink* link)
  80 {
  81     if (!WEBKIT_IS_ACCESSIBLE_HYPERLINK(link))
  82         return 0;
  83
  84     return core(WEBKIT_ACCESSIBLE_HYPERLINK(link));
  85 }
  86
  87 static AccessibilityObject* core(AtkAction* action)
  88 {
  89     return core(WEBKIT_ACCESSIBLE_HYPERLINK(action));
  90 }
  91
  92
  93 static gboolean webkitAccessibleHyperlinkActionDoAction(AtkAction* action, gint index)
  94 {
  95     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE_HYPERLINK(action), FALSE);
  96     g_return_val_if_fail(WEBKIT_ACCESSIBLE_HYPERLINK(action)->priv->hyperlinkImpl, FALSE);
  97     g_return_val_if_fail(!index, 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
 114     if (!ATK_IS_ACTION(WEBKIT_ACCESSIBLE_HYPERLINK(action)->priv->hyperlinkImpl))
 115         return 0;
 116
 117     return 1;
 118 }
 119
 120 static const gchar* webkitAccessibleHyperlinkActionGetDescription(AtkAction* action, gint index)
 121 {
 122     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE_HYPERLINK(action), 0);
 123     g_return_val_if_fail(WEBKIT_ACCESSIBLE_HYPERLINK(action)->priv->hyperlinkImpl, 0);
 124     g_return_val_if_fail(!index, 0);
 125
 126     // TODO: Need a way to provide/localize action descriptions.
 127     notImplemented();
 128     return "";
 129 }
 130
 131 static const gchar* webkitAccessibleHyperlinkActionGetKeybinding(AtkAction* action, gint index)
 132 {
 133     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE_HYPERLINK(action), 0);
 134     g_return_val_if_fail(WEBKIT_ACCESSIBLE_HYPERLINK(action)->priv->hyperlinkImpl, 0);
 135     g_return_val_if_fail(!index, 0);
 136
 137     if (!ATK_IS_ACTION(WEBKIT_ACCESSIBLE_HYPERLINK(action)->priv->hyperlinkImpl))
 138         return 0;
 139
 140     AccessibilityObject* coreObject = core(action);
 141     if (!coreObject)
 142         return 0;
 143
 144     return returnString(coreObject->accessKey().string());
 145 }
 146
 147 static const gchar* webkitAccessibleHyperlinkActionGetName(AtkAction* action, gint index)
 148 {
 149     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE_HYPERLINK(action), 0);
 150     g_return_val_if_fail(WEBKIT_ACCESSIBLE_HYPERLINK(action)->priv->hyperlinkImpl, 0);
 151     g_return_val_if_fail(!index, 0);
 152
 153     if (!ATK_IS_ACTION(WEBKIT_ACCESSIBLE_HYPERLINK(action)->priv->hyperlinkImpl))
 154         return 0;
 155
 156     AccessibilityObject* coreObject = core(action);
 157     if (!coreObject)
 158         return 0;
 159
 160     return returnString(coreObject->actionVerb());
 161 }
 162
 163 static void atkActionInterfaceInit(AtkActionIface* iface)
 164 {
 165     iface->do_action = webkitAccessibleHyperlinkActionDoAction;
 166     iface->get_n_actions = webkitAccessibleHyperlinkActionGetNActions;
 167     iface->get_description = webkitAccessibleHyperlinkActionGetDescription;
 168     iface->get_keybinding = webkitAccessibleHyperlinkActionGetKeybinding;
 169     iface->get_name = webkitAccessibleHyperlinkActionGetName;
 170 }
 171
 172 static gchar* webkitAccessibleHyperlinkGetURI(AtkHyperlink* link, gint index)
 173 {
 174     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE_HYPERLINK(link), 0);
 175     // FIXME: Do NOT support more than one instance of an AtkObject
 176     // implementing AtkHyperlinkImpl in every instance of AtkHyperLink
 177     g_return_val_if_fail(!index, 0);
 178
 179     AccessibilityObject* coreObject = core(link);
 180     if (!coreObject || coreObject->url().isNull())
 181         return 0;
 182
 183     return g_strdup(returnString(coreObject->url().string()));
 184 }
 185
 186 static AtkObject* webkitAccessibleHyperlinkGetObject(AtkHyperlink* link, gint index)
 187 {
 188     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE_HYPERLINK(link), 0);
 189     g_return_val_if_fail(WEBKIT_ACCESSIBLE_HYPERLINK(link)->priv->hyperlinkImpl, 0);
 190
 191     // FIXME: Do NOT support more than one instance of an AtkObject
 192     // implementing AtkHyperlinkImpl in every instance of AtkHyperLink
 193     g_return_val_if_fail(!index, 0);
 194
 195     return ATK_OBJECT(WEBKIT_ACCESSIBLE_HYPERLINK(link)->priv->hyperlinkImpl);
 196 }
 197
 198 static gint getRangeLengthForObject(AccessibilityObject* obj, Range* range)
 199 {
 200     // This is going to be the actual length in most of the cases
 201     int baseLength = TextIterator::rangeLength(range, true);
 202
 203     // Check whether the current hyperlink belongs to a list item.
 204     // If so, we need to consider the length of the item's marker
 205     AccessibilityObject* parent = obj->parentObjectUnignored();
 206     if (!parent || !parent->isAccessibilityRenderObject() || !parent->isListItem())
 207         return baseLength;
 208
 209     // Even if we don't expose list markers to Assistive
 210     // Technologies, we need to have a way to measure their length
 211     // for those cases when it's needed to take it into account
 212     // separately (as in getAccessibilityObjectForOffset)
 213     AccessibilityObject* markerObj = parent->firstChild();
 214     if (!markerObj)
 215         return baseLength;
 216
 217     RenderObject* renderer = markerObj->renderer();
 218     if (!renderer || !renderer->isListMarker())
 219         return baseLength;
 220
 221     RenderListMarker* marker = toRenderListMarker(renderer);
 222     return baseLength + marker->text().length() + marker->suffix().length();
 223 }
 224
 225 static gint webkitAccessibleHyperlinkGetStartIndex(AtkHyperlink* link)
 226 {
 227     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE_HYPERLINK(link), 0);
 228
 229     AccessibilityObject* coreObject = core(link);
 230     if (!coreObject)
 231         return 0;
 232
 233     AccessibilityObject* parentUnignored = coreObject->parentObjectUnignored();
 234     if (!parentUnignored)
 235         return 0;
 236
 237     Node* node = coreObject->node();
 238     if (!node)
 239         return 0;
 240
 241     Node* parentNode = parentUnignored->node();
 242     if (!parentNode)
 243         return 0;
 244
 245     RefPtr<Range> range = Range::create(node->document(), firstPositionInOrBeforeNode(parentNode), firstPositionInOrBeforeNode(node));
 246     return getRangeLengthForObject(coreObject, range.get());
 247 }
 248
 249 static gint webkitAccessibleHyperlinkGetEndIndex(AtkHyperlink* link)
 250 {
 251     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE_HYPERLINK(link), 0);
 252
 253     AccessibilityObject* coreObject = core(link);
 254     if (!coreObject)
 255         return 0;
 256
 257     AccessibilityObject* parentUnignored = coreObject->parentObjectUnignored();
 258     if (!parentUnignored)
 259         return 0;
 260
 261     Node* node = coreObject->node();
 262     if (!node)
 263         return 0;
 264
 265     Node* parentNode = parentUnignored->node();
 266     if (!parentNode)
 267         return 0;
 268
 269     RefPtr<Range> range = Range::create(node->document(), firstPositionInOrBeforeNode(parentNode), lastPositionInOrAfterNode(node));
 270     return getRangeLengthForObject(coreObject, range.get());
 271 }
 272
 273 static gboolean webkitAccessibleHyperlinkIsValid(AtkHyperlink* link)
 274 {
 275     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE_HYPERLINK(link), 0);
 276     g_return_val_if_fail(WEBKIT_ACCESSIBLE_HYPERLINK(link)->priv->hyperlinkImpl, FALSE);
 277
 278     // Link is valid for the whole object's lifetime
 279     return TRUE;
 280 }
 281
 282 static gint webkitAccessibleHyperlinkGetNAnchors(AtkHyperlink* link)
 283 {
 284     // FIXME Do NOT support more than one instance of an AtkObject
 285     // implementing AtkHyperlinkImpl in every instance of AtkHyperLink
 286     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE_HYPERLINK(link), 0);
 287     g_return_val_if_fail(WEBKIT_ACCESSIBLE_HYPERLINK(link)->priv->hyperlinkImpl, 0);
 288     return 1;
 289 }
 290
 291 static gboolean webkitAccessibleHyperlinkIsSelectedLink(AtkHyperlink* link)
 292 {
 293     // Not implemented: this function is deprecated in ATK now
 294     notImplemented();
 295     return FALSE;
 296 }
 297
 298 static void webkitAccessibleHyperlinkGetProperty(GObject* object, guint propId, GValue* value, GParamSpec* pspec)
 299 {
 300     switch (propId) {
 301     case PROP_HYPERLINK_IMPL:
 302         g_value_set_object(value, WEBKIT_ACCESSIBLE_HYPERLINK(object)->priv->hyperlinkImpl);
 303         break;
 304     default:
 305         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propId, pspec);
 306     }
 307 }
 308
 309 static void webkitAccessibleHyperlinkSetProperty(GObject* object, guint propId, const GValue* value, GParamSpec* pspec)
 310 {
 311     WebKitAccessibleHyperlinkPrivate* priv = WEBKIT_ACCESSIBLE_HYPERLINK(object)->priv;
 312
 313     switch (propId) {
 314     case PROP_HYPERLINK_IMPL:
 315         // No need to check and unref previous values of
 316         // priv->hyperlinkImpl as this is a CONSTRUCT ONLY property
 317         priv->hyperlinkImpl = WEBKIT_ACCESSIBLE(g_value_get_object(value));
 318         g_object_weak_ref(G_OBJECT(priv->hyperlinkImpl), (GWeakNotify)g_object_unref, object);
 319         break;
 320     default:
 321         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propId, pspec);
 322     }
 323 }
 324
 325 static void webkitAccessibleHyperlinkFinalize(GObject* object)
 326 {
 327     G_OBJECT_CLASS(webkitAccessibleHyperlinkParentClass)->finalize(object);
 328 }
 329
 330 static void webkitAccessibleHyperlinkClassInit(AtkHyperlinkClass* klass)
 331 {
 332     GObjectClass* gobjectClass = G_OBJECT_CLASS(klass);
 333
 334     webkitAccessibleHyperlinkParentClass = g_type_class_peek_parent(klass);
 335
 336     gobjectClass->finalize = webkitAccessibleHyperlinkFinalize;
 337     gobjectClass->set_property = webkitAccessibleHyperlinkSetProperty;
 338     gobjectClass->get_property = webkitAccessibleHyperlinkGetProperty;
 339
 340     klass->get_uri = webkitAccessibleHyperlinkGetURI;
 341     klass->get_object = webkitAccessibleHyperlinkGetObject;
 342     klass->get_start_index = webkitAccessibleHyperlinkGetStartIndex;
 343     klass->get_end_index = webkitAccessibleHyperlinkGetEndIndex;
 344     klass->is_valid = webkitAccessibleHyperlinkIsValid;
 345     klass->get_n_anchors = webkitAccessibleHyperlinkGetNAnchors;
 346     klass->is_selected_link = webkitAccessibleHyperlinkIsSelectedLink;
 347
 348     g_object_class_install_property(gobjectClass, PROP_HYPERLINK_IMPL,
 349                                     g_param_spec_object("hyperlink-impl",
 350                                                         "Hyperlink implementation",
 351                                                         "The associated WebKitAccessible instance.",
 352                                                         WEBKIT_TYPE_ACCESSIBLE,
 353                                                         (GParamFlags)(G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS)));
 354
 355     g_type_class_add_private(gobjectClass, sizeof(WebKitAccessibleHyperlinkPrivate));
 356 }
 357
 358 static void webkitAccessibleHyperlinkInit(AtkHyperlink* link)
 359 {
 360     WEBKIT_ACCESSIBLE_HYPERLINK(link)->priv = WEBKIT_ACCESSIBLE_HYPERLINK_GET_PRIVATE(link);
 361     WEBKIT_ACCESSIBLE_HYPERLINK(link)->priv->hyperlinkImpl = 0;
 362 }
 363
 364 GType webkitAccessibleHyperlinkGetType()
 365 {
 366     static volatile gsize typeVolatile = 0;
 367
 368     if (g_once_init_enter(&typeVolatile)) {
 369         static const GTypeInfo tinfo = {
 370             sizeof(WebKitAccessibleHyperlinkClass),
 371             (GBaseInitFunc) 0,
 372             (GBaseFinalizeFunc) 0,
 373             (GClassInitFunc) webkitAccessibleHyperlinkClassInit,
 374             (GClassFinalizeFunc) 0,
 375             0, /* class data */
 376             sizeof(WebKitAccessibleHyperlink), /* instance size */
 377             0, /* nb preallocs */
 378             (GInstanceInitFunc) webkitAccessibleHyperlinkInit,
 379             0 /* value table */
 380         };
 381
 382         static const GInterfaceInfo actionInfo = {
 383             (GInterfaceInitFunc)(GInterfaceInitFunc)atkActionInterfaceInit,
 384             (GInterfaceFinalizeFunc) 0, 0
 385         };
 386
 387         GType type = g_type_register_static(ATK_TYPE_HYPERLINK, "WebKitAccessibleHyperlink", &tinfo, GTypeFlags(0));
 388         g_type_add_interface_static(type, ATK_TYPE_ACTION, &actionInfo);
 389
 390         g_once_init_leave(&typeVolatile, type);
 391     }
 392
 393     return typeVolatile;
 394 }
 395
 396 WebKitAccessibleHyperlink* webkitAccessibleHyperlinkNew(AtkHyperlinkImpl* hyperlinkImpl)
 397 {
 398     g_return_val_if_fail(ATK_IS_HYPERLINK_IMPL(hyperlinkImpl), 0);
 399     return WEBKIT_ACCESSIBLE_HYPERLINK(g_object_new(WEBKIT_TYPE_ACCESSIBLE_HYPERLINK, "hyperlink-impl", hyperlinkImpl, 0));
 400 }
 401
 402 WebCore::AccessibilityObject* webkitAccessibleHyperlinkGetAccessibilityObject(WebKitAccessibleHyperlink* link)
 403 {
 404     g_return_val_if_fail(WEBKIT_IS_ACCESSIBLE_HYPERLINK(link), 0);
 405     return core(link);
 406 }
 407
 408 #endif // HAVE(ACCESSIBILITY)