AXObjectCacheAtk.cpp 7.73 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
/*
 * Copyright (C) 2008 Nuanti Ltd.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */

#include "config.h"
#include "AXObjectCache.h"

#include "AccessibilityObject.h"
#include "AccessibilityObjectWrapperAtk.h"
25 26
#include "Document.h"
#include "Element.h"
27 28
#include "GOwnPtr.h"
#include "Range.h"
29
#include "SelectElement.h"
30
#include "TextIterator.h"
31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

namespace WebCore {

void AXObjectCache::detachWrapper(AccessibilityObject* obj)
{
    webkit_accessible_detach(WEBKIT_ACCESSIBLE(obj->wrapper()));
}

void AXObjectCache::attachWrapper(AccessibilityObject* obj)
{
    AtkObject* atkObj = ATK_OBJECT(webkit_accessible_new(obj));
    obj->setWrapper(atkObj);
    g_object_unref(atkObj);
}

46
static AccessibilityObject* getListObject(AccessibilityObject* object)
47
{
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
    // Only list boxes and menu lists supported so far.
    if (!object->isListBox() && !object->isMenuList())
        return 0;

    // For list boxes the list object is just itself.
    if (object->isListBox())
        return object;

    // For menu lists we need to return the first accessible child,
    // with role MenuListPopupRole, since that's the one holding the list
    // of items with role MenuListOptionRole.
    AccessibilityObject::AccessibilityChildrenVector children = object->children();
    if (!children.size())
        return 0;

    AccessibilityObject* listObject = children.at(0).get();
    if (!listObject->isMenuListPopup())
        return 0;

    return listObject;
}
69

70 71 72 73 74 75 76 77 78 79 80
static void notifyChildrenSelectionChange(AccessibilityObject* object)
{
    // This static variables are needed to keep track of the old
    // focused object and its associated list object, as per previous
    // calls to this function, in order to properly decide whether to
    // emit some signals or not.
    DEFINE_STATIC_LOCAL(RefPtr<AccessibilityObject>, oldListObject, ());
    DEFINE_STATIC_LOCAL(RefPtr<AccessibilityObject>, oldFocusedObject, ());

    // Only list boxes and menu lists supported so far.
    if (!object || !(object->isListBox() || object->isMenuList()))
81 82 83 84 85 86 87 88 89 90
        return;

    // Emit signal from the listbox's point of view first.
    g_signal_emit_by_name(object->wrapper(), "selection-changed");

    // Find the item where the selection change was triggered from.
    SelectElement* select = toSelectElement(static_cast<Element*>(object->node()));
    if (!select)
        return;
    int changedItemIndex = select->activeSelectionStartListIndex();
91 92 93 94 95 96 97 98

    AccessibilityObject* listObject = getListObject(object);
    if (!listObject) {
        oldListObject = 0;
        return;
    }

    AccessibilityObject::AccessibilityChildrenVector items = listObject->children();
99 100 101 102
    if (changedItemIndex < 0 || changedItemIndex >= static_cast<int>(items.size()))
        return;
    AccessibilityObject* item = items.at(changedItemIndex).get();

103 104 105 106
    // Ensure the current list object is the same than the old one so
    // further comparisons make sense. Otherwise, just reset
    // oldFocusedObject so it won't be taken into account.
    if (oldListObject != listObject)
107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
        oldFocusedObject = 0;

    AtkObject* axItem = item ? item->wrapper() : 0;
    AtkObject* axOldFocusedObject = oldFocusedObject ? oldFocusedObject->wrapper() : 0;

    // Old focused object just lost focus, so emit the events.
    if (axOldFocusedObject && axItem != axOldFocusedObject) {
        g_signal_emit_by_name(axOldFocusedObject, "focus-event", false);
        g_signal_emit_by_name(axOldFocusedObject, "state-change", "focused", false);
    }

    // Emit needed events for the currently (un)selected item.
    if (axItem) {
        bool isSelected = item->isSelected();
        g_signal_emit_by_name(axItem, "state-change", "selected", isSelected);
        g_signal_emit_by_name(axItem, "focus-event", isSelected);
        g_signal_emit_by_name(axItem, "state-change", "focused", isSelected);
    }

126 127
    // Update pointers to the previously involved objects.
    oldListObject = listObject;
128 129 130
    oldFocusedObject = item;
}

131
void AXObjectCache::postPlatformNotification(AccessibilityObject* coreObject, AXNotification notification)
132
{
133 134 135 136
    AtkObject* axObject = coreObject->wrapper();
    if (!axObject)
        return;

137
    if (notification == AXCheckedStateChanged) {
138 139
        if (!coreObject->isCheckboxOrRadio())
            return;
140
        g_signal_emit_by_name(axObject, "state-change", "checked", coreObject->isChecked());
141 142 143 144 145
    } else if (notification == AXSelectedChildrenChanged || notification == AXMenuListValueChanged) {
        if (notification == AXMenuListValueChanged && coreObject->isMenuList()) {
            g_signal_emit_by_name(axObject, "focus-event", true);
            g_signal_emit_by_name(axObject, "state-change", "focused", true);
        }
146
        notifyChildrenSelectionChange(coreObject);
147 148 149 150 151 152 153 154 155 156 157
    } else if (notification == AXValueChanged) {
        if (!ATK_IS_VALUE(axObject))
            return;

        AtkPropertyValues propertyValues;
        propertyValues.property_name = "accessible-value";

        memset(&propertyValues.new_value,  0, sizeof(GValue));
        atk_value_get_current_value(ATK_VALUE(axObject), &propertyValues.new_value);

        g_signal_emit_by_name(ATK_OBJECT(axObject), "property-change::accessible-value", &propertyValues, NULL);
158
    }
159 160
}

161
static void emitTextChanged(AccessibilityObject* object, AXObjectCache::AXTextChange textChange, unsigned offset, unsigned count)
162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190
{
    // Get the axObject for the parent object
    AtkObject* wrapper = object->parentObjectUnignored()->wrapper();
    if (!wrapper || !ATK_IS_TEXT(wrapper))
        return;

    // Select the right signal to be emitted
    CString detail;
    switch (textChange) {
    case AXObjectCache::AXTextInserted:
        detail = "text-changed::insert";
        break;
    case AXObjectCache::AXTextDeleted:
        detail = "text-changed::delete";
        break;
    }

    if (!detail.isNull())
        g_signal_emit_by_name(wrapper, detail.data(), offset, count);
}

void AXObjectCache::nodeTextChangePlatformNotification(AccessibilityObject* object, AXTextChange textChange, unsigned offset, unsigned count)
{
    // Sanity check
    if (count < 1 || !object || !object->isAccessibilityRenderObject())
        return;

    Node* node = object->node();
    RefPtr<Range> range = Range::create(node->document(),  Position(node->parentNode(), 0), Position(node, 0));
191
    emitTextChanged(object, textChange, offset + TextIterator::rangeLength(range.get()), count);
192 193
}

194
void AXObjectCache::handleFocusedUIElementChanged(RenderObject* oldFocusedRender, RenderObject* newFocusedRender)
195 196 197 198 199 200 201 202 203 204 205 206 207
{
    RefPtr<AccessibilityObject> oldObject = getOrCreate(oldFocusedRender);
    if (oldObject) {
        g_signal_emit_by_name(oldObject->wrapper(), "focus-event", false);
        g_signal_emit_by_name(oldObject->wrapper(), "state-change", "focused", false);
    }
    RefPtr<AccessibilityObject> newObject = getOrCreate(newFocusedRender);
    if (newObject) {
        g_signal_emit_by_name(newObject->wrapper(), "focus-event", true);
        g_signal_emit_by_name(newObject->wrapper(), "state-change", "focused", true);
    }
}

208 209 210 211
void AXObjectCache::handleScrolledToAnchor(const Node*)
{
}

212
} // namespace WebCore