1 /*

     2  * Copyright (C) 2008 Nuanti Ltd.

     3  * Copyright (C) 2009 Igalia S.L.

     4  * Copyright (C) 2009 Jan Alonzo

     5  *

     6  * Portions from Mozilla a11y, copyright as follows:

     7  *

     8  * The Original Code is mozilla.org code.

     9  *

    10  * The Initial Developer of the Original Code is

    11  * Sun Microsystems, Inc.

    12  * Portions created by the Initial Developer are Copyright (C) 2002

    13  * the Initial Developer. All Rights Reserved.

    14  *

    15  * This library is free software; you can redistribute it and/or

    16  * modify it under the terms of the GNU Library General Public

    17  * License as published by the Free Software Foundation; either

    18  * version 2 of the License, or (at your option) any later version.

    19  *

    20  * This library is distributed in the hope that it will be useful,

    21  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    23  * Library General Public License for more details.

    24  *

    25  * You should have received a copy of the GNU Library General Public License

    26  * along with this library; see the file COPYING.LIB.  If not, write to

    27  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

    28  * Boston, MA 02110-1301, USA.

    29  */

    30 

    31 #include "config.h"

    32 #include "AccessibilityObjectWrapperAtk.h"

    33 

    34 #if HAVE(ACCESSIBILITY)

    35 

    36 #include "AXObjectCache.h"

    37 #include "AccessibilityListBox.h"

    38 #include "AccessibilityListBoxOption.h"

    39 #include "AccessibilityRenderObject.h"

    40 #include "AccessibilityTable.h"

    41 #include "AccessibilityTableCell.h"

    42 #include "AccessibilityTableColumn.h"

    43 #include "AccessibilityTableRow.h"

    44 #include "AtomicString.h"

    45 #include "Document.h"

    46 #include "DocumentType.h"

    47 #include "Editor.h"

    48 #include "Frame.h"

    49 #include "FrameView.h"

    50 #include "GOwnPtr.h"

    51 #include "HostWindow.h"

    52 #include "HTMLNames.h"

    53 #include "HTMLTableCaptionElement.h"

    54 #include "HTMLTableElement.h"

    55 #include "InlineTextBox.h"

    56 #include "IntRect.h"

    57 #include "NotImplemented.h"

    58 #include "RenderText.h"

    59 #include "TextEncoding.h"

    60 #include <wtf/text/CString.h>

    61 

    62 #include <atk/atk.h>

    63 #include <glib.h>

    64 #include <glib/gprintf.h>

    65 #include <libgail-util/gail-util.h>

    66 #include <pango/pango.h>

    67 

    68 using namespace WebCore;

    69 

    70 static AccessibilityObject* fallbackObject()

    71 {

    72     static AXObjectCache* fallbackCache = new AXObjectCache;

    73     static AccessibilityObject* object = 0;

    74     if (!object) {

    75         // FIXME: using fallbackCache->getOrCreate(ListBoxOptionRole) is a hack

    76         object = fallbackCache->getOrCreate(ListBoxOptionRole);

    77         object->ref();

    78     }

    79 

    80     return object;

    81 }

    82 

    83 // Used to provide const char* returns.

    84 static const char* returnString(const String& str)

    85 {

    86     static CString returnedString;

    87     returnedString = str.utf8();

    88     return returnedString.data();

    89 }

    90 

    91 static AccessibilityObject* core(WebKitAccessible* accessible)

    92 {

    93     if (!accessible)

    94         return 0;

    95 

    96     return accessible->m_object;

    97 }

    98 

    99 static AccessibilityObject* core(AtkObject* object)

   100 {

   101     if (!WEBKIT_IS_ACCESSIBLE(object))

   102         return 0;

   103 

   104     return core(WEBKIT_ACCESSIBLE(object));

   105 }

   106 

   107 static AccessibilityObject* core(AtkAction* action)

   108 {

   109     return core(ATK_OBJECT(action));

   110 }

   111 

   112 static AccessibilityObject* core(AtkSelection* selection)

   113 {

   114     return core(ATK_OBJECT(selection));

   115 }

   116 

   117 static AccessibilityObject* core(AtkText* text)

   118 {

   119     return core(ATK_OBJECT(text));

   120 }

   121 

   122 static AccessibilityObject* core(AtkEditableText* text)

   123 {

   124     return core(ATK_OBJECT(text));

   125 }

   126 

   127 static AccessibilityObject* core(AtkComponent* component)

   128 {

   129     return core(ATK_OBJECT(component));

   130 }

   131 

   132 static AccessibilityObject* core(AtkImage* image)

   133 {

   134     return core(ATK_OBJECT(image));

   135 }

   136 

   137 static AccessibilityObject* core(AtkTable* table)

   138 {

   139     return core(ATK_OBJECT(table));

   140 }

   141 

   142 static AccessibilityObject* core(AtkDocument* document)

   143 {

   144     return core(ATK_OBJECT(document));

   145 }

   146 

   147 static gchar* webkit_accessible_text_get_text(AtkText* text, gint startOffset, gint endOffset);

   148 

   149 static const gchar* webkit_accessible_get_name(AtkObject* object)

   150 {

   151     AccessibilityObject* coreObject = core(object);

   152     if (!coreObject->isAccessibilityRenderObject())

   153         return returnString(coreObject->stringValue());

   154 

   155     AccessibilityRenderObject* renderObject = static_cast<AccessibilityRenderObject*>(coreObject);

   156     if (coreObject->isControl()) {

   157         AccessibilityObject* label = renderObject->correspondingLabelForControlElement();

   158         if (label) {

   159             AtkObject* atkObject = label->wrapper();

   160             if (ATK_IS_TEXT(atkObject))

   161                 return webkit_accessible_text_get_text(ATK_TEXT(atkObject), 0, -1);

   162         }

   163     }

   164 

   165     if (renderObject->isImage() || renderObject->isInputImage()) {

   166         Node* node = renderObject->renderer()->node();

   167         if (node && node->isHTMLElement()) {

   168             // Get the attribute rather than altText String so as not to fall back on title.

   169             String alt = static_cast<HTMLElement*>(node)->getAttribute(HTMLNames::altAttr);

   170             if (!alt.isEmpty())

   171                 return returnString(alt);

   172         }

   173     }

   174 

   175     return returnString(coreObject->stringValue());

   176 }

   177 

   178 static const gchar* webkit_accessible_get_description(AtkObject* object)

   179 {

   180     AccessibilityObject* coreObject = core(object);

   181     Node* node = 0;

   182     if (coreObject->isAccessibilityRenderObject())

   183         node = static_cast<AccessibilityRenderObject*>(coreObject)->renderer()->node();

   184     if (!node || !node->isHTMLElement() || coreObject->ariaRoleAttribute() != UnknownRole)

   185         return returnString(coreObject->accessibilityDescription());

   186 

   187     // atk_table_get_summary returns an AtkObject. We have no summary object, so expose summary here.

   188     if (coreObject->roleValue() == TableRole) {

   189         String summary = static_cast<HTMLTableElement*>(node)->summary();

   190         if (!summary.isEmpty())

   191             return returnString(summary);

   192     }

   193 

   194     // The title attribute should be reliably available as the object's descripton.

   195     // We do not want to fall back on other attributes in its absence. See bug 25524.

   196     String title = static_cast<HTMLElement*>(node)->title();

   197     if (!title.isEmpty())

   198         return returnString(title);

   199 

   200     return returnString(coreObject->accessibilityDescription());

   201 }

   202 

   203 static void setAtkRelationSetFromCoreObject(AccessibilityObject* coreObject, AtkRelationSet* relationSet)

   204 {

   205     AccessibilityRenderObject* accObject = static_cast<AccessibilityRenderObject*>(coreObject);

   206     if (accObject->isControl()) {

   207         AccessibilityObject* label = accObject->correspondingLabelForControlElement();

   208         if (label)

   209             atk_relation_set_add_relation_by_type(relationSet, ATK_RELATION_LABELLED_BY, label->wrapper());

   210     } else {

   211         AccessibilityObject* control = accObject->correspondingControlForLabelElement();

   212         if (control)

   213             atk_relation_set_add_relation_by_type(relationSet, ATK_RELATION_LABEL_FOR, control->wrapper());

   214     }

   215 }

   216 

   217 static gpointer webkit_accessible_parent_class = 0;

   218 

   219 static AtkObject* atkParentOfWebView(AtkObject* object)

   220 {

   221     AccessibilityObject* coreParent = core(object)->parentObjectUnignored();

   222 

   223     // The top level web view claims to not have a parent. This makes it

   224     // impossible for assistive technologies to ascend the accessible

   225     // hierarchy all the way to the application. (Bug 30489)

   226     if (!coreParent && core(object)->isWebArea()) {

   227         HostWindow* hostWindow = core(object)->document()->view()->hostWindow();

   228         if (hostWindow) {

   229             PlatformPageClient webView = hostWindow->platformPageClient();

   230             if (webView) {

   231                 GtkWidget* webViewParent = gtk_widget_get_parent(webView);

   232                 if (webViewParent)

   233                     return gtk_widget_get_accessible(webViewParent);

   234             }

   235         }

   236     }

   237 

   238     if (!coreParent)

   239         return 0;

   240 

   241     return coreParent->wrapper();

   242 }

   243 

   244 static AtkObject* webkit_accessible_get_parent(AtkObject* object)

   245 {

   246     AccessibilityObject* coreParent = core(object)->parentObjectUnignored();

   247     if (!coreParent && core(object)->isWebArea())

   248         return atkParentOfWebView(object);

   249 

   250     if (!coreParent)

   251         return 0;

   252 

   253     return coreParent->wrapper();

   254 }

   255 

   256 static gint webkit_accessible_get_n_children(AtkObject* object)

   257 {

   258     return core(object)->children().size();

   259 }

   260 

   261 static AtkObject* webkit_accessible_ref_child(AtkObject* object, gint index)

   262 {

   263     AccessibilityObject* coreObject = core(object);

   264     AccessibilityObject::AccessibilityChildrenVector children = coreObject->children();

   265     if (index < 0 || static_cast<unsigned>(index) >= children.size())

   266         return 0;

   267 

   268     AccessibilityObject* coreChild = children.at(index).get();

   269 

   270     if (!coreChild)

   271         return 0;

   272 

   273     AtkObject* child = coreChild->wrapper();

   274     atk_object_set_parent(child, object);

   275     g_object_ref(child);

   276 

   277     return child;

   278 }

   279 

   280 static gint webkit_accessible_get_index_in_parent(AtkObject* object)

   281 {

   282     AccessibilityObject* coreObject = core(object);

   283     AccessibilityObject* parent = coreObject->parentObjectUnignored();

   284 

   285     if (!parent && core(object)->isWebArea()) {

   286         AtkObject* atkParent = atkParentOfWebView(object);

   287         if (!atkParent)

   288             return -1;

   289 

   290         unsigned count = atk_object_get_n_accessible_children(atkParent);

   291         for (unsigned i = 0; i < count; ++i) {

   292             AtkObject* child = atk_object_ref_accessible_child(atkParent, i);

   293             bool childIsObject = child == object;

   294             g_object_unref(child);

   295             if (childIsObject)

   296                 return i;

   297         }

   298     }

   299 

   300     AccessibilityObject::AccessibilityChildrenVector children = parent->children();

   301     unsigned count = children.size();

   302     for (unsigned i = 0; i < count; ++i) {

   303         if (children[i] == coreObject)

   304             return i;

   305     }

   306 

   307     return -1;

   308 }

   309 

   310 static AtkAttributeSet* addAttributeToSet(AtkAttributeSet* attributeSet, const char* name, const char* value)

   311 {

   312     AtkAttribute* attribute = static_cast<AtkAttribute*>(g_malloc(sizeof(AtkAttribute)));

   313     attribute->name = g_strdup(name);

   314     attribute->value = g_strdup(value);

   315     attributeSet = g_slist_prepend(attributeSet, attribute);

   316 

   317     return attributeSet;

   318 }

   319 

   320 static AtkAttributeSet* webkit_accessible_get_attributes(AtkObject* object)

   321 {

   322     AtkAttributeSet* attributeSet = 0;

   323 

   324     attributeSet = addAttributeToSet(attributeSet, "toolkit", "WebKitGtk");

   325 

   326     int headingLevel = core(object)->headingLevel();

   327     if (headingLevel) {

   328         String value = String::number(headingLevel);

   329         attributeSet = addAttributeToSet(attributeSet, "level", value.utf8().data());

   330     }

   331     return attributeSet;

   332 }

   333 

   334 static AtkRole atkRole(AccessibilityRole role)

   335 {

   336     switch (role) {

   337     case UnknownRole:

   338         return ATK_ROLE_UNKNOWN;

   339     case ButtonRole:

   340         return ATK_ROLE_PUSH_BUTTON;

   341     case RadioButtonRole:

   342         return ATK_ROLE_RADIO_BUTTON;

   343     case CheckBoxRole:

   344         return ATK_ROLE_CHECK_BOX;

   345     case SliderRole:

   346         return ATK_ROLE_SLIDER;

   347     case TabGroupRole:

   348         return ATK_ROLE_PAGE_TAB_LIST;

   349     case TextFieldRole:

   350     case TextAreaRole:

   351         return ATK_ROLE_ENTRY;

   352     case StaticTextRole:

   353         return ATK_ROLE_TEXT;

   354     case OutlineRole:

   355         return ATK_ROLE_TREE;

   356     case MenuBarRole:

   357         return ATK_ROLE_MENU_BAR;

   358     case MenuListPopupRole:

   359     case MenuRole:

   360         return ATK_ROLE_MENU;

   361     case MenuListOptionRole:

   362     case MenuItemRole:

   363         return ATK_ROLE_MENU_ITEM;

   364     case ColumnRole:

   365         //return ATK_ROLE_TABLE_COLUMN_HEADER; // Is this right?

   366         return ATK_ROLE_UNKNOWN; // Matches Mozilla

   367     case RowRole:

   368         //return ATK_ROLE_TABLE_ROW_HEADER; // Is this right?

   369         return ATK_ROLE_LIST_ITEM; // Matches Mozilla

   370     case ToolbarRole:

   371         return ATK_ROLE_TOOL_BAR;

   372     case BusyIndicatorRole:

   373         return ATK_ROLE_PROGRESS_BAR; // Is this right?

   374     case ProgressIndicatorRole:

   375         //return ATK_ROLE_SPIN_BUTTON; // Some confusion about this role in AccessibilityRenderObject.cpp

   376         return ATK_ROLE_PROGRESS_BAR;

   377     case WindowRole:

   378         return ATK_ROLE_WINDOW;

   379     case PopUpButtonRole:

   380     case ComboBoxRole:

   381         return ATK_ROLE_COMBO_BOX;

   382     case SplitGroupRole:

   383         return ATK_ROLE_SPLIT_PANE;

   384     case SplitterRole:

   385         return ATK_ROLE_SEPARATOR;

   386     case ColorWellRole:

   387         return ATK_ROLE_COLOR_CHOOSER;

   388     case ListRole:

   389         return ATK_ROLE_LIST;

   390     case ScrollBarRole:

   391         return ATK_ROLE_SCROLL_BAR;

   392     case GridRole: // Is this right?

   393     case TableRole:

   394         return ATK_ROLE_TABLE;

   395     case ApplicationRole:

   396         return ATK_ROLE_APPLICATION;

   397     case GroupRole:

   398     case RadioGroupRole:

   399         return ATK_ROLE_PANEL;

   400     case CellRole:

   401         return ATK_ROLE_TABLE_CELL;

   402     case LinkRole:

   403     case WebCoreLinkRole:

   404     case ImageMapLinkRole:

   405         return ATK_ROLE_LINK;

   406     case ImageMapRole:

   407     case ImageRole:

   408         return ATK_ROLE_IMAGE;

   409     case ListMarkerRole:

   410         return ATK_ROLE_TEXT;

   411     case WebAreaRole:

   412         //return ATK_ROLE_HTML_CONTAINER; // Is this right?

   413         return ATK_ROLE_DOCUMENT_FRAME;

   414     case HeadingRole:

   415         return ATK_ROLE_HEADING;

   416     case ListBoxRole:

   417         return ATK_ROLE_LIST;

   418     case ListItemRole:

   419     case ListBoxOptionRole:

   420         return ATK_ROLE_LIST_ITEM;

   421     default:

   422         return ATK_ROLE_UNKNOWN;

   423     }

   424 }

   425 

   426 static AtkRole webkit_accessible_get_role(AtkObject* object)

   427 {

   428     AccessibilityObject* axObject = core(object);

   429 

   430     if (!axObject)

   431         return ATK_ROLE_UNKNOWN;

   432 

   433     // WebCore does not know about paragraph role, label role, or section role

   434     if (axObject->isAccessibilityRenderObject()) {

   435         Node* node = static_cast<AccessibilityRenderObject*>(axObject)->renderer()->node();

   436         if (node) {

   437             if (node->hasTagName(HTMLNames::pTag))

   438                 return ATK_ROLE_PARAGRAPH;

   439             if (node->hasTagName(HTMLNames::labelTag))

   440                 return ATK_ROLE_LABEL;

   441             if (node->hasTagName(HTMLNames::divTag))

   442                 return ATK_ROLE_SECTION;

   443             if (node->hasTagName(HTMLNames::formTag))

   444                 return ATK_ROLE_FORM;

   445         }

   446     }

   447 

   448     // Note: Why doesn't WebCore have a password field for this

   449     if (axObject->isPasswordField())

   450         return ATK_ROLE_PASSWORD_TEXT;

   451 

   452     return atkRole(axObject->roleValue());

   453 }

   454 

   455 static void setAtkStateSetFromCoreObject(AccessibilityObject* coreObject, AtkStateSet* stateSet)

   456 {

   457     AccessibilityObject* parent = coreObject->parentObject();

   458     bool isListBoxOption = parent && parent->isListBox();

   459 

   460     // Please keep the state list in alphabetical order

   461     if (coreObject->isChecked())

   462         atk_state_set_add_state(stateSet, ATK_STATE_CHECKED);

   463 

   464     // FIXME: isReadOnly does not seem to do the right thing for

   465     // controls, so check explicitly for them. In addition, because

   466     // isReadOnly is false for listBoxOptions, we need to add one

   467     // more check so that we do not present them as being "editable".

   468     if ((!coreObject->isReadOnly() ||

   469         (coreObject->isControl() && coreObject->canSetValueAttribute())) &&

   470         !isListBoxOption)

   471         atk_state_set_add_state(stateSet, ATK_STATE_EDITABLE);

   472 

   473     // FIXME: Put both ENABLED and SENSITIVE together here for now

   474     if (coreObject->isEnabled()) {

   475         atk_state_set_add_state(stateSet, ATK_STATE_ENABLED);

   476         atk_state_set_add_state(stateSet, ATK_STATE_SENSITIVE);

   477     }

   478 

   479     if (coreObject->canSetFocusAttribute())

   480         atk_state_set_add_state(stateSet, ATK_STATE_FOCUSABLE);

   481 

   482     if (coreObject->isFocused())

   483         atk_state_set_add_state(stateSet, ATK_STATE_FOCUSED);

   484 

   485     // TODO: ATK_STATE_HORIZONTAL

   486 

   487     if (coreObject->isIndeterminate())

   488         atk_state_set_add_state(stateSet, ATK_STATE_INDETERMINATE);

   489 

   490     if (coreObject->isMultiSelectable())

   491         atk_state_set_add_state(stateSet, ATK_STATE_MULTISELECTABLE);

   492 

   493     // TODO: ATK_STATE_OPAQUE

   494 

   495     if (coreObject->isPressed())

   496         atk_state_set_add_state(stateSet, ATK_STATE_PRESSED);

   497 

   498     // TODO: ATK_STATE_SELECTABLE_TEXT

   499 

   500     if (coreObject->canSetSelectedAttribute()) {

   501         atk_state_set_add_state(stateSet, ATK_STATE_SELECTABLE);

   502         // Items in focusable lists in Gtk have both STATE_SELECT{ABLE,ED}

   503         // and STATE_FOCUS{ABLE,ED}. We'll fake the latter based on the

   504         // former.

   505         if (isListBoxOption)

   506             atk_state_set_add_state(stateSet, ATK_STATE_FOCUSABLE);

   507     }

   508 

   509     if (coreObject->isSelected()) {

   510         atk_state_set_add_state(stateSet, ATK_STATE_SELECTED);

   511         // Items in focusable lists in Gtk have both STATE_SELECT{ABLE,ED}

   512         // and STATE_FOCUS{ABLE,ED}. We'll fake the latter based on the

   513         // former.

   514         if (isListBoxOption)

   515             atk_state_set_add_state(stateSet, ATK_STATE_FOCUSED);

   516     }

   517 

   518     // FIXME: Group both SHOWING and VISIBLE here for now

   519     // Not sure how to handle this in WebKit, see bug

   520     // http://bugzilla.gnome.org/show_bug.cgi?id=509650 for other

   521     // issues with SHOWING vs VISIBLE within GTK+

   522     if (!coreObject->isOffScreen()) {

   523         atk_state_set_add_state(stateSet, ATK_STATE_SHOWING);

   524         atk_state_set_add_state(stateSet, ATK_STATE_VISIBLE);

   525     }

   526 

   527     // Mutually exclusive, so we group these two

   528     if (coreObject->roleValue() == TextFieldRole)

   529         atk_state_set_add_state(stateSet, ATK_STATE_SINGLE_LINE);

   530     else if (coreObject->roleValue() == TextAreaRole)

   531         atk_state_set_add_state(stateSet, ATK_STATE_MULTI_LINE);

   532 

   533     // TODO: ATK_STATE_SENSITIVE

   534 

   535     // TODO: ATK_STATE_VERTICAL

   536 

   537     if (coreObject->isVisited())

   538         atk_state_set_add_state(stateSet, ATK_STATE_VISITED);

   539 }

   540 

   541 static AtkStateSet* webkit_accessible_ref_state_set(AtkObject* object)

   542 {

   543     AtkStateSet* stateSet = ATK_OBJECT_CLASS(webkit_accessible_parent_class)->ref_state_set(object);

   544     AccessibilityObject* coreObject = core(object);

   545 

   546     if (coreObject == fallbackObject()) {

   547         atk_state_set_add_state(stateSet, ATK_STATE_DEFUNCT);

   548         return stateSet;

   549     }

   550 

   551     setAtkStateSetFromCoreObject(coreObject, stateSet);

   552 

   553     return stateSet;

   554 }

   555 

   556 static AtkRelationSet* webkit_accessible_ref_relation_set(AtkObject* object)

   557 {

   558     AtkRelationSet* relationSet = ATK_OBJECT_CLASS(webkit_accessible_parent_class)->ref_relation_set(object);

   559     AccessibilityObject* coreObject = core(object);

   560 

   561     setAtkRelationSetFromCoreObject(coreObject, relationSet);

   562 

   563     return relationSet;

   564 }

   565 

   566 static void webkit_accessible_init(AtkObject* object, gpointer data)

   567 {

   568     if (ATK_OBJECT_CLASS(webkit_accessible_parent_class)->initialize)

   569         ATK_OBJECT_CLASS(webkit_accessible_parent_class)->initialize(object, data);

   570 

   571     WEBKIT_ACCESSIBLE(object)->m_object = reinterpret_cast<AccessibilityObject*>(data);

   572 }

   573 

   574 static void webkit_accessible_finalize(GObject* object)

   575 {

   576     // This is a good time to clear the return buffer.

   577     returnString(String());

   578 

   579     G_OBJECT_CLASS(webkit_accessible_parent_class)->finalize(object);

   580 }

   581 

   582 static void webkit_accessible_class_init(AtkObjectClass* klass)

   583 {

   584     GObjectClass* gobjectClass = G_OBJECT_CLASS(klass);

   585 

   586     webkit_accessible_parent_class = g_type_class_peek_parent(klass);

   587 

   588     gobjectClass->finalize = webkit_accessible_finalize;

   589 

   590     klass->initialize = webkit_accessible_init;

   591     klass->get_name = webkit_accessible_get_name;

   592     klass->get_description = webkit_accessible_get_description;

   593     klass->get_parent = webkit_accessible_get_parent;

   594     klass->get_n_children = webkit_accessible_get_n_children;

   595     klass->ref_child = webkit_accessible_ref_child;

   596     klass->get_role = webkit_accessible_get_role;

   597     klass->ref_state_set = webkit_accessible_ref_state_set;

   598     klass->get_index_in_parent = webkit_accessible_get_index_in_parent;

   599     klass->get_attributes = webkit_accessible_get_attributes;

   600     klass->ref_relation_set = webkit_accessible_ref_relation_set;

   601 }

   602 

   603 GType

   604 webkit_accessible_get_type(void)

   605 {

   606     static volatile gsize type_volatile = 0;

   607 

   608     if (g_once_init_enter(&type_volatile)) {

   609         static const GTypeInfo tinfo = {

   610             sizeof(WebKitAccessibleClass),

   611             (GBaseInitFunc) 0,

   612             (GBaseFinalizeFunc) 0,

   613             (GClassInitFunc) webkit_accessible_class_init,

   614             (GClassFinalizeFunc) 0,

   615             0, /* class data */

   616             sizeof(WebKitAccessible), /* instance size */

   617             0, /* nb preallocs */

   618             (GInstanceInitFunc) 0,

   619             0 /* value table */

   620         };

   621 

   622         GType type = g_type_register_static(ATK_TYPE_OBJECT,

   623                                             "WebKitAccessible", &tinfo, GTypeFlags(0));

   624         g_once_init_leave(&type_volatile, type);

   625     }

   626 

   627     return type_volatile;

   628 }

   629 

   630 static gboolean webkit_accessible_action_do_action(AtkAction* action, gint i)

   631 {

   632     g_return_val_if_fail(i == 0, FALSE);

   633     return core(action)->performDefaultAction();

   634 }

   635 

   636 static gint webkit_accessible_action_get_n_actions(AtkAction* action)

   637 {

   638     return 1;

   639 }

   640 

   641 static const gchar* webkit_accessible_action_get_description(AtkAction* action, gint i)

   642 {

   643     g_return_val_if_fail(i == 0, 0);

   644     // TODO: Need a way to provide/localize action descriptions.

   645     notImplemented();

   646     return "";

   647 }

   648 

   649 static const gchar* webkit_accessible_action_get_keybinding(AtkAction* action, gint i)

   650 {

   651     g_return_val_if_fail(i == 0, 0);

   652     // FIXME: Construct a proper keybinding string.

   653     return returnString(core(action)->accessKey().string());

   654 }

   655 

   656 static const gchar* webkit_accessible_action_get_name(AtkAction* action, gint i)

   657 {

   658     g_return_val_if_fail(i == 0, 0);

   659     return returnString(core(action)->actionVerb());

   660 }

   661 

   662 static void atk_action_interface_init(AtkActionIface* iface)

   663 {

   664     iface->do_action = webkit_accessible_action_do_action;

   665     iface->get_n_actions = webkit_accessible_action_get_n_actions;

   666     iface->get_description = webkit_accessible_action_get_description;

   667     iface->get_keybinding = webkit_accessible_action_get_keybinding;

   668     iface->get_name = webkit_accessible_action_get_name;

   669 }

   670 

   671 // Selection (for controls)

   672 

   673 static AccessibilityObject* optionFromList(AtkSelection* selection, gint i)

   674 {

   675     AccessibilityObject* coreSelection = core(selection);

   676     if (!coreSelection || i < 0)

   677         return 0;

   678 

   679     AccessibilityRenderObject::AccessibilityChildrenVector options = core(selection)->children();

   680     if (i < static_cast<gint>(options.size()))

   681         return options.at(i).get();

   682 

   683     return 0;

   684 }

   685 

   686 static AccessibilityObject* optionFromSelection(AtkSelection* selection, gint i)

   687 {

   688     // i is the ith selection as opposed to the ith child.

   689 

   690     AccessibilityObject* coreSelection = core(selection);

   691     if (!coreSelection || i < 0)

   692         return 0;

   693 

   694     AccessibilityRenderObject::AccessibilityChildrenVector selectedItems;

   695     if (coreSelection->isListBox())

   696         static_cast<AccessibilityListBox*>(coreSelection)->selectedChildren(selectedItems);

   697 

   698     // TODO: Combo boxes

   699 

   700     if (i < static_cast<gint>(selectedItems.size()))

   701         return selectedItems.at(i).get();

   702 

   703     return 0;

   704 }

   705 

   706 static gboolean webkit_accessible_selection_add_selection(AtkSelection* selection, gint i)

   707 {

   708     AccessibilityObject* option = optionFromList(selection, i);

   709     if (option && core(selection)->isListBox()) {

   710         AccessibilityListBoxOption* listBoxOption = static_cast<AccessibilityListBoxOption*>(option);

   711         listBoxOption->setSelected(true);

   712         return listBoxOption->isSelected();

   713     }

   714 

   715     return false;

   716 }

   717 

   718 static gboolean webkit_accessible_selection_clear_selection(AtkSelection* selection)

   719 {

   720     AccessibilityObject* coreSelection = core(selection);

   721     if (!coreSelection)

   722         return false;

   723 

   724     AccessibilityRenderObject::AccessibilityChildrenVector selectedItems;

   725     if (coreSelection->isListBox()) {

   726         // Set the list of selected items to an empty list; then verify that it worked.

   727         AccessibilityListBox* listBox = static_cast<AccessibilityListBox*>(coreSelection);

   728         listBox->setSelectedChildren(selectedItems);

   729         listBox->selectedChildren(selectedItems);

   730         return selectedItems.size() == 0;

   731     }

   732     return false;

   733 }

   734 

   735 static AtkObject* webkit_accessible_selection_ref_selection(AtkSelection* selection, gint i)

   736 {

   737     AccessibilityObject* option = optionFromSelection(selection, i);

   738     if (option) {

   739         AtkObject* child = option->wrapper();

   740         g_object_ref(child);

   741         return child;

   742     }

   743 

   744     return 0;

   745 }

   746 

   747 static gint webkit_accessible_selection_get_selection_count(AtkSelection* selection)

   748 {

   749     AccessibilityObject* coreSelection = core(selection);

   750     if (coreSelection && coreSelection->isListBox()) {

   751         AccessibilityRenderObject::AccessibilityChildrenVector selectedItems;

   752         static_cast<AccessibilityListBox*>(coreSelection)->selectedChildren(selectedItems);

   753         return static_cast<gint>(selectedItems.size());

   754     }

   755 

   756     return 0;

   757 }

   758 

   759 static gboolean webkit_accessible_selection_is_child_selected(AtkSelection* selection, gint i)

   760 {

   761     AccessibilityObject* option = optionFromList(selection, i);

   762     if (option && core(selection)->isListBox())

   763         return static_cast<AccessibilityListBoxOption*>(option)->isSelected();

   764 

   765     return false;

   766 }

   767 

   768 static gboolean webkit_accessible_selection_remove_selection(AtkSelection* selection, gint i)

   769 {

   770     // TODO: This is only getting called if i == 0. What is preventing the rest?

   771     AccessibilityObject* option = optionFromSelection(selection, i);

   772     if (option && core(selection)->isListBox()) {

   773         AccessibilityListBoxOption* listBoxOption = static_cast<AccessibilityListBoxOption*>(option);

   774         listBoxOption->setSelected(false);

   775         return !listBoxOption->isSelected();

   776     }

   777 

   778     return false;

   779 }

   780 

   781 static gboolean webkit_accessible_selection_select_all_selection(AtkSelection* selection)

   782 {

   783     AccessibilityObject* coreSelection = core(selection);

   784     if (!coreSelection || !coreSelection->isMultiSelectable())

   785         return false;

   786 

   787     AccessibilityRenderObject::AccessibilityChildrenVector children = coreSelection->children();

   788     if (coreSelection->isListBox()) {

   789         AccessibilityListBox* listBox = static_cast<AccessibilityListBox*>(coreSelection);

   790         listBox->setSelectedChildren(children);

   791         AccessibilityRenderObject::AccessibilityChildrenVector selectedItems;

   792         listBox->selectedChildren(selectedItems);

   793         return selectedItems.size() == children.size();

   794     }

   795 

   796     return false;

   797 }

   798 

   799 static void atk_selection_interface_init(AtkSelectionIface* iface)

   800 {

   801     iface->add_selection = webkit_accessible_selection_add_selection;

   802     iface->clear_selection = webkit_accessible_selection_clear_selection;

   803     iface->ref_selection = webkit_accessible_selection_ref_selection;

   804     iface->get_selection_count = webkit_accessible_selection_get_selection_count;

   805     iface->is_child_selected = webkit_accessible_selection_is_child_selected;

   806     iface->remove_selection = webkit_accessible_selection_remove_selection;

   807     iface->select_all_selection = webkit_accessible_selection_select_all_selection;

   808 }

   809 

   810 // Text

   811 

   812 static gchar* utf8Substr(const gchar* string, gint start, gint end)

   813 {

   814     ASSERT(string);

   815     glong strLen = g_utf8_strlen(string, -1);

   816     if (start > strLen || end > strLen)

   817         return 0;

   818     gchar* startPtr = g_utf8_offset_to_pointer(string, start);

   819     gsize lenInBytes = g_utf8_offset_to_pointer(string, end) -  startPtr + 1;

   820     gchar* output = static_cast<gchar*>(g_malloc0(lenInBytes + 1));

   821     return g_utf8_strncpy(output, startPtr, end - start + 1);

   822 }

   823 

   824 // This function is not completely general, is it's tied to the

   825 // internals of WebCore's text presentation.

   826 static gchar* convertUniCharToUTF8(const UChar* characters, gint length, int from, int to)

   827 {

   828     CString stringUTF8 = UTF8Encoding().encode(characters, length, QuestionMarksForUnencodables);

   829     gchar* utf8String = utf8Substr(stringUTF8.data(), from, to);

   830     if (!g_utf8_validate(utf8String, -1, 0)) {

   831         g_free(utf8String);

   832         return 0;

   833     }

   834     gsize len = strlen(utf8String);

   835     GString* ret = g_string_new_len(0, len);

   836     gchar* ptr = utf8String;

   837 

   838     // WebCore introduces line breaks in the text that do not reflect

   839     // the layout you see on the screen, replace them with spaces

   840     while (len > 0) {

   841         gint index, start;

   842         pango_find_paragraph_boundary(ptr, len, &index, &start);

   843         g_string_append_len(ret, ptr, index);

   844         if (index == start)

   845             break;

   846         g_string_append_c(ret, ' ');

   847         ptr += start;

   848         len -= start;

   849     }

   850 

   851     g_free(utf8String);

   852     return g_string_free(ret, FALSE);

   853 }

   854 

   855 gchar* textForObject(AccessibilityRenderObject* accObject)

   856 {

   857     GString* str = g_string_new(0);

   858 

   859     // For text controls, we can get the text line by line.

   860     if (accObject->isTextControl()) {

   861         unsigned textLength = accObject->textLength();

   862         int lineNumber = 0;

   863         PlainTextRange range = accObject->doAXRangeForLine(lineNumber);

   864         while (range.length) {

   865             // When a line of text wraps in a text area, the final space is removed.

   866             if (range.start + range.length < textLength)

   867                 range.length -= 1;

   868             String lineText = accObject->doAXStringForRange(range);

   869             g_string_append(str, lineText.utf8().data());

   870             g_string_append(str, "\n");

   871             range = accObject->doAXRangeForLine(++lineNumber);

   872         }

   873     } else if (accObject->renderer()) {

   874         // For RenderBlocks, piece together the text from the RenderText objects they contain.

   875         for (RenderObject* obj = accObject->renderer()->firstChild(); obj; obj = obj->nextSibling()) {

   876             if (obj->isBR()) {

   877                 g_string_append(str, "\n");

   878                 continue;

   879             }

   880 

   881             RenderText* renderText;

   882             if (obj->isText())

   883                 renderText = toRenderText(obj);

   884             else if (obj->firstChild() && obj->firstChild()->isText()) {

   885                 // Handle RenderInlines (and any other similiar RenderObjects).

   886                 renderText = toRenderText(obj->firstChild());

   887             } else

   888                 continue;

   889 

   890             InlineTextBox* box = renderText->firstTextBox();

   891             while (box) {

   892                 gchar* text = convertUniCharToUTF8(renderText->characters(), renderText->textLength(), box->start(), box->end());

   893                 g_string_append(str, text);

   894                 // Newline chars in the source result in separate text boxes, so check

   895                 // before adding a newline in the layout. See bug 25415 comment #78.

   896                 // If the next sibling is a BR, we'll add the newline when we examine that child.

   897                 if (!box->nextOnLineExists() && (!obj->nextSibling() || !obj->nextSibling()->isBR()))

   898                     g_string_append(str, "\n");

   899                 box = box->nextTextBox();

   900             }

   901         }

   902     }

   903     return g_string_free(str, FALSE);

   904 }

   905 

   906 static gchar* webkit_accessible_text_get_text(AtkText* text, gint startOffset, gint endOffset)

   907 {

   908     AccessibilityObject* coreObject = core(text);

   909     String ret;

   910     unsigned start = startOffset;

   911     if (endOffset == -1) {

   912         endOffset = coreObject->stringValue().length();

   913         if (!endOffset)

   914             endOffset = coreObject->textUnderElement().length();

   915     }

   916     int length = endOffset - startOffset;

   917 

   918     if (coreObject->isTextControl())

   919         ret = coreObject->doAXStringForRange(PlainTextRange(start, length));

   920     else

   921         ret = coreObject->textUnderElement().substring(start, length);

   922 

   923     if (!ret.length()) {

   924         // This can happen at least with anonymous RenderBlocks (e.g. body text amongst paragraphs)

   925         ret = String(textForObject(static_cast<AccessibilityRenderObject*>(coreObject)));

   926         if (!endOffset)

   927             endOffset = ret.length();

   928         ret = ret.substring(start, endOffset - startOffset);

   929     }

   930 

   931     return g_strdup(ret.utf8().data());

   932 }

   933 

   934 static GailTextUtil* getGailTextUtilForAtk(AtkText* textObject)

   935 {

   936     gpointer data = g_object_get_data(G_OBJECT(textObject), "webkit-accessible-gail-text-util");

   937     if (data)

   938         return static_cast<GailTextUtil*>(data);

   939 

   940     GailTextUtil* gailTextUtil = gail_text_util_new();

   941     gail_text_util_text_setup(gailTextUtil, webkit_accessible_text_get_text(textObject, 0, -1));

   942     g_object_set_data_full(G_OBJECT(textObject), "webkit-accessible-gail-text-util", gailTextUtil, g_object_unref);

   943     return gailTextUtil;

   944 }

   945 

   946 static PangoLayout* getPangoLayoutForAtk(AtkText* textObject)

   947 {

   948     AccessibilityObject* coreObject = core(textObject);

   949 

   950     HostWindow* hostWindow = coreObject->document()->view()->hostWindow();

   951     if (!hostWindow)

   952         return 0;

   953     PlatformPageClient webView = hostWindow->platformPageClient();

   954     if (!webView)

   955         return 0;

   956 

   957     AccessibilityRenderObject* accObject = static_cast<AccessibilityRenderObject*>(coreObject);

   958     if (!accObject)

   959         return 0;

   960 

   961     // Create a string with the layout as it appears on the screen

   962     PangoLayout* layout = gtk_widget_create_pango_layout(static_cast<GtkWidget*>(webView), textForObject(accObject));

   963     g_object_set_data_full(G_OBJECT(textObject), "webkit-accessible-pango-layout", layout, g_object_unref);

   964     return layout;

   965 }

   966 

   967 static gchar* webkit_accessible_text_get_text_after_offset(AtkText* text, gint offset, AtkTextBoundary boundaryType, gint* startOffset, gint* endOffset)

   968 {

   969     return gail_text_util_get_text(getGailTextUtilForAtk(text), getPangoLayoutForAtk(text), GAIL_AFTER_OFFSET, boundaryType, offset, startOffset, endOffset);

   970 }

   971 

   972 static gchar* webkit_accessible_text_get_text_at_offset(AtkText* text, gint offset, AtkTextBoundary boundaryType, gint* startOffset, gint* endOffset)

   973 {

   974     return gail_text_util_get_text(getGailTextUtilForAtk(text), getPangoLayoutForAtk(text), GAIL_AT_OFFSET, boundaryType, offset, startOffset, endOffset);

   975 }

   976 

   977 static gchar* webkit_accessible_text_get_text_before_offset(AtkText* text, gint offset, AtkTextBoundary boundaryType, gint* startOffset, gint* endOffset)

   978 {

   979     return gail_text_util_get_text(getGailTextUtilForAtk(text), getPangoLayoutForAtk(text), GAIL_BEFORE_OFFSET, boundaryType, offset, startOffset, endOffset);

   980 }

   981 

   982 static gunichar webkit_accessible_text_get_character_at_offset(AtkText* text, gint offset)

   983 {

   984     notImplemented();

   985     return 0;

   986 }

   987 

   988 static gint webkit_accessible_text_get_caret_offset(AtkText* text)

   989 {

   990     // coreObject is the unignored object whose offset the caller is requesting.

   991     // focusedObject is the object with the caret. It is likely ignored -- unless it's a link.

   992     AccessibilityObject* coreObject = core(text);

   993     Node* focusedNode = coreObject->selection().end().node();

   994 

   995     if (!focusedNode)

   996         return 0;

   997 

   998     RenderObject* focusedRenderer = focusedNode->renderer();

   999     AccessibilityObject* focusedObject = coreObject->document()->axObjectCache()->getOrCreate(focusedRenderer);

  1000 

  1001     int offset;

  1002     // Don't ignore links if the offset is being requested for a link.

  1003     objectAndOffsetUnignored(focusedObject, offset, !coreObject->isLink());

  1004 

  1005     // TODO: Verify this for RTL text.

  1006     return offset;

  1007 }

  1008 

  1009 static AtkAttributeSet* getAttributeSetForAccessibilityObject(const AccessibilityObject* object)

  1010 {

  1011     if (!object->isAccessibilityRenderObject())

  1012         return 0;

  1013 

  1014     RenderObject* renderer = static_cast<const AccessibilityRenderObject*>(object)->renderer();

  1015     RenderStyle* style = renderer->style();

  1016 

  1017     AtkAttributeSet* result = 0;

  1018     GOwnPtr<gchar> buffer(g_strdup_printf("%i", style->fontSize()));

  1019     result = addAttributeToSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_SIZE), buffer.get());

  1020 

  1021     Color bgColor = style->visitedDependentColor(CSSPropertyBackgroundColor);

  1022     if (bgColor.isValid()) {

  1023         buffer.set(g_strdup_printf("%i,%i,%i",

  1024                                    bgColor.red(), bgColor.green(), bgColor.blue()));

  1025         result = addAttributeToSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_BG_COLOR), buffer.get());

  1026     }

  1027 

  1028     Color fgColor = style->visitedDependentColor(CSSPropertyColor);

  1029     if (fgColor.isValid()) {

  1030         buffer.set(g_strdup_printf("%i,%i,%i",

  1031                                    fgColor.red(), fgColor.green(), fgColor.blue()));

  1032         result = addAttributeToSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_FG_COLOR), buffer.get());

  1033     }

  1034 

  1035     int baselinePosition;

  1036     bool includeRise = true;

  1037     switch (style->verticalAlign()) {

  1038     case SUB:

  1039         baselinePosition = -1 * renderer->baselinePosition(true);

  1040         break;

  1041     case SUPER:

  1042         baselinePosition = renderer->baselinePosition(true);

  1043         break;

  1044     case BASELINE:

  1045         baselinePosition = 0;

  1046         break;

  1047     default:

  1048         includeRise = false;

  1049         break;

  1050     }

  1051 

  1052     if (includeRise) {

  1053         buffer.set(g_strdup_printf("%i", baselinePosition));

  1054         result = addAttributeToSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_RISE), buffer.get());

  1055     }

  1056 

  1057     int indentation = style->textIndent().calcValue(object->size().width());

  1058     if (indentation != undefinedLength) {

  1059         buffer.set(g_strdup_printf("%i", indentation));

  1060         result = addAttributeToSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_INDENT), buffer.get());

  1061     }

  1062 

  1063     String fontFamilyName = style->font().family().family().string();

  1064     if (fontFamilyName.left(8) == "-webkit-")

  1065         fontFamilyName = fontFamilyName.substring(8);

  1066 

  1067     result = addAttributeToSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_FAMILY_NAME), fontFamilyName.utf8().data());

  1068 

  1069     int fontWeight = -1;

  1070     switch (style->font().weight()) {

  1071     case FontWeight100:

  1072         fontWeight = 100;

  1073         break;

  1074     case FontWeight200:

  1075         fontWeight = 200;

  1076         break;

  1077     case FontWeight300:

  1078         fontWeight = 300;

  1079         break;

  1080     case FontWeight400:

  1081         fontWeight = 400;

  1082         break;

  1083     case FontWeight500:

  1084         fontWeight = 500;

  1085         break;

  1086     case FontWeight600:

  1087         fontWeight = 600;

  1088         break;

  1089     case FontWeight700:

  1090         fontWeight = 700;

  1091         break;

  1092     case FontWeight800:

  1093         fontWeight = 800;

  1094         break;

  1095     case FontWeight900:

  1096         fontWeight = 900;

  1097     }

  1098     if (fontWeight > 0) {

  1099         buffer.set(g_strdup_printf("%i", fontWeight));

  1100         result = addAttributeToSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_WEIGHT), buffer.get());

  1101     }

  1102 

  1103     switch (style->textAlign()) {

  1104     case TAAUTO:

  1105         break;

  1106     case LEFT:

  1107     case WEBKIT_LEFT:

  1108         result = addAttributeToSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_JUSTIFICATION), "left");

  1109         break;

  1110     case RIGHT:

  1111     case WEBKIT_RIGHT:

  1112         result = addAttributeToSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_JUSTIFICATION), "right");

  1113         break;

  1114     case CENTER:

  1115     case WEBKIT_CENTER:

  1116         result = addAttributeToSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_JUSTIFICATION), "center");

  1117         break;

  1118     case JUSTIFY:

  1119         result = addAttributeToSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_JUSTIFICATION), "fill");

  1120     }

  1121 

  1122     result = addAttributeToSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_UNDERLINE), (style->textDecoration() & UNDERLINE) ? "single" : "none");

  1123 

  1124     result = addAttributeToSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_STYLE), style->font().italic() ? "italic" : "normal");

  1125 

  1126     result = addAttributeToSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_STRIKETHROUGH), (style->textDecoration() & LINE_THROUGH) ? "true" : "false");

  1127 

  1128     result = addAttributeToSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_INVISIBLE), (style->visibility() == HIDDEN) ? "true" : "false");

  1129 

  1130     result = addAttributeToSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_EDITABLE), object->isReadOnly() ? "false" : "true");

  1131 

  1132     return result;

  1133 }

  1134 

  1135 static gint compareAttribute(const AtkAttribute* a, const AtkAttribute* b)