/*

 * Copyright (C) 2008 Nuanti Ltd.

 * Copyright (C) 2009 Igalia S.L.

 * Copyright (C) 2009 Jan Alonzo

 *

 * Portions from Mozilla a11y, copyright as follows:

 *

 * The Original Code is mozilla.org code.

 *

 * The Initial Developer of the Original Code is

 * Sun Microsystems, Inc.

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

 * the Initial Developer. All Rights Reserved.

 *

 * 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 "AccessibilityObjectWrapperAtk.h"

#if HAVE(ACCESSIBILITY)

#include "AXObjectCache.h"

#include "AccessibilityListBox.h"

#include "AccessibilityListBoxOption.h"

#include "AccessibilityRenderObject.h"

#include "AccessibilityTable.h"

#include "AccessibilityTableCell.h"

#include "AccessibilityTableColumn.h"

#include "AccessibilityTableRow.h"

#include "AtomicString.h"

#include "Document.h"

#include "DocumentType.h"

#include "Editor.h"

#include "Frame.h"

#include "FrameView.h"

#include "GOwnPtr.h"

#include "HostWindow.h"

#include "HTMLNames.h"

#include "HTMLTableCaptionElement.h"

#include "HTMLTableElement.h"

#include "InlineTextBox.h"

#include "IntRect.h"

#include "NotImplemented.h"

#include "RenderText.h"

#include "TextEncoding.h"

#include <wtf/text/CString.h>

#include <atk/atk.h>

#include <glib.h>

#include <glib/gprintf.h>

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

#include <pango/pango.h>

using namespace WebCore;

static AccessibilityObject* fallbackObject()

{

    static AXObjectCache* fallbackCache = new AXObjectCache;

    static AccessibilityObject* object = 0;

    if (!object) {

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

        object = fallbackCache->getOrCreate(ListBoxOptionRole);

        object->ref();

    }

    return object;

}

// Used to provide const char* returns.

static const char* returnString(const String& str)

{

    static CString returnedString;

    returnedString = str.utf8();

    return returnedString.data();

}

static AccessibilityObject* core(WebKitAccessible* accessible)

{

    if (!accessible)

        return 0;

    return accessible->m_object;

}

static AccessibilityObject* core(AtkObject* object)

{

    if (!WEBKIT_IS_ACCESSIBLE(object))

        return 0;

    return core(WEBKIT_ACCESSIBLE(object));

}

static AccessibilityObject* core(AtkAction* action)

{

    return core(ATK_OBJECT(action));

}

static AccessibilityObject* core(AtkSelection* selection)

{

    return core(ATK_OBJECT(selection));

}

static AccessibilityObject* core(AtkText* text)

{

    return core(ATK_OBJECT(text));

}

static AccessibilityObject* core(AtkEditableText* text)

{

    return core(ATK_OBJECT(text));

}

static AccessibilityObject* core(AtkComponent* component)

{

    return core(ATK_OBJECT(component));

}

static AccessibilityObject* core(AtkImage* image)

{

    return core(ATK_OBJECT(image));

}

static AccessibilityObject* core(AtkTable* table)

{

    return core(ATK_OBJECT(table));

}

static AccessibilityObject* core(AtkDocument* document)

{

    return core(ATK_OBJECT(document));

}

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

static const gchar* webkit_accessible_get_name(AtkObject* object)

{

    AccessibilityObject* coreObject = core(object);

    if (!coreObject->isAccessibilityRenderObject())

        return returnString(coreObject->stringValue());

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

    if (coreObject->isControl()) {

        AccessibilityObject* label = renderObject->correspondingLabelForControlElement();

        if (label) {

            AtkObject* atkObject = label->wrapper();

            if (ATK_IS_TEXT(atkObject))

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

        }

    }

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

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

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

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

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

            if (!alt.isEmpty())

                return returnString(alt);

        }

    }

    return returnString(coreObject->stringValue());

}

static const gchar* webkit_accessible_get_description(AtkObject* object)

{

    AccessibilityObject* coreObject = core(object);

    Node* node = 0;

    if (coreObject->isAccessibilityRenderObject())

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

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

        return returnString(coreObject->accessibilityDescription());

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

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

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

        if (!summary.isEmpty())

            return returnString(summary);

    }

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

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

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

    if (!title.isEmpty())

        return returnString(title);

    return returnString(coreObject->accessibilityDescription());

}

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

{

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

    if (accObject->isControl()) {

        AccessibilityObject* label = accObject->correspondingLabelForControlElement();

        if (label)

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

    } else {

        AccessibilityObject* control = accObject->correspondingControlForLabelElement();

        if (control)

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

    }

}

static gpointer webkit_accessible_parent_class = 0;

static AtkObject* atkParentOfWebView(AtkObject* object)

{

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

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

    // impossible for assistive technologies to ascend the accessible

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

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

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

        if (hostWindow) {

            PlatformPageClient webView = hostWindow->platformPageClient();

            if (webView) {

                GtkWidget* webViewParent = gtk_widget_get_parent(webView);

                if (webViewParent)

                    return gtk_widget_get_accessible(webViewParent);

            }

        }

    }

    if (!coreParent)

        return 0;

    return coreParent->wrapper();

}

static AtkObject* webkit_accessible_get_parent(AtkObject* object)

{

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

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

        return atkParentOfWebView(object);

    if (!coreParent)

        return 0;

    return coreParent->wrapper();

}

static gint webkit_accessible_get_n_children(AtkObject* object)

{

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

}

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

{

    AccessibilityObject* coreObject = core(object);

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

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

        return 0;

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

    if (!coreChild)

        return 0;

    AtkObject* child = coreChild->wrapper();

    atk_object_set_parent(child, object);

    g_object_ref(child);

    return child;

}

static gint webkit_accessible_get_index_in_parent(AtkObject* object)

{

    AccessibilityObject* coreObject = core(object);

    AccessibilityObject* parent = coreObject->parentObjectUnignored();

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

        AtkObject* atkParent = atkParentOfWebView(object);

        if (!atkParent)

            return -1;

        unsigned count = atk_object_get_n_accessible_children(atkParent);

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

            AtkObject* child = atk_object_ref_accessible_child(atkParent, i);

            bool childIsObject = child == object;

            g_object_unref(child);

            if (childIsObject)

                return i;

        }

    }

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

    unsigned count = children.size();

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

        if (children[i] == coreObject)

            return i;

    }

    return -1;

}

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

{

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

    attribute->name = g_strdup(name);

    attribute->value = g_strdup(value);

    attributeSet = g_slist_prepend(attributeSet, attribute);

    return attributeSet;

}

static AtkAttributeSet* webkit_accessible_get_attributes(AtkObject* object)

{

    AtkAttributeSet* attributeSet = 0;

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

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

    if (headingLevel) {

        String value = String::number(headingLevel);

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

    }

    return attributeSet;

}

static AtkRole atkRole(AccessibilityRole role)

{

    switch (role) {

    case UnknownRole:

        return ATK_ROLE_UNKNOWN;

    case ButtonRole:

        return ATK_ROLE_PUSH_BUTTON;

    case RadioButtonRole:

        return ATK_ROLE_RADIO_BUTTON;

    case CheckBoxRole:

        return ATK_ROLE_CHECK_BOX;

    case SliderRole:

        return ATK_ROLE_SLIDER;

    case TabGroupRole:

        return ATK_ROLE_PAGE_TAB_LIST;

    case TextFieldRole:

    case TextAreaRole:

        return ATK_ROLE_ENTRY;

    case StaticTextRole:

        return ATK_ROLE_TEXT;

    case OutlineRole:

        return ATK_ROLE_TREE;

    case MenuBarRole:

        return ATK_ROLE_MENU_BAR;

    case MenuListPopupRole:

    case MenuRole:

        return ATK_ROLE_MENU;

    case MenuListOptionRole:

    case MenuItemRole:

        return ATK_ROLE_MENU_ITEM;

    case ColumnRole:

        //return ATK_ROLE_TABLE_COLUMN_HEADER; // Is this right?

        return ATK_ROLE_UNKNOWN; // Matches Mozilla

    case RowRole:

        //return ATK_ROLE_TABLE_ROW_HEADER; // Is this right?

        return ATK_ROLE_LIST_ITEM; // Matches Mozilla

    case ToolbarRole:

        return ATK_ROLE_TOOL_BAR;

    case BusyIndicatorRole:

        return ATK_ROLE_PROGRESS_BAR; // Is this right?

    case ProgressIndicatorRole:

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

        return ATK_ROLE_PROGRESS_BAR;

    case WindowRole:

        return ATK_ROLE_WINDOW;

    case PopUpButtonRole:

    case ComboBoxRole:

        return ATK_ROLE_COMBO_BOX;

    case SplitGroupRole:

        return ATK_ROLE_SPLIT_PANE;

    case SplitterRole:

        return ATK_ROLE_SEPARATOR;

    case ColorWellRole:

        return ATK_ROLE_COLOR_CHOOSER;

    case ListRole:

        return ATK_ROLE_LIST;

    case ScrollBarRole:

        return ATK_ROLE_SCROLL_BAR;

    case GridRole: // Is this right?

    case TableRole:

        return ATK_ROLE_TABLE;

    case ApplicationRole:

        return ATK_ROLE_APPLICATION;

    case GroupRole:

    case RadioGroupRole:

        return ATK_ROLE_PANEL;

    case CellRole:

        return ATK_ROLE_TABLE_CELL;

    case LinkRole:

    case WebCoreLinkRole:

    case ImageMapLinkRole:

        return ATK_ROLE_LINK;

    case ImageMapRole:

    case ImageRole:

        return ATK_ROLE_IMAGE;

    case ListMarkerRole:

        return ATK_ROLE_TEXT;

    case WebAreaRole:

        //return ATK_ROLE_HTML_CONTAINER; // Is this right?

        return ATK_ROLE_DOCUMENT_FRAME;

    case HeadingRole:

        return ATK_ROLE_HEADING;

    case ListBoxRole:

        return ATK_ROLE_LIST;

    case ListItemRole:

    case ListBoxOptionRole:

        return ATK_ROLE_LIST_ITEM;

    default:

        return ATK_ROLE_UNKNOWN;

    }

}

static AtkRole webkit_accessible_get_role(AtkObject* object)

{

    AccessibilityObject* axObject = core(object);

    if (!axObject)

        return ATK_ROLE_UNKNOWN;

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

    if (axObject->isAccessibilityRenderObject()) {

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

        if (node) {

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

                return ATK_ROLE_PARAGRAPH;

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

                return ATK_ROLE_LABEL;

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

                return ATK_ROLE_SECTION;

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

                return ATK_ROLE_FORM;

        }

    }

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

    if (axObject->isPasswordField())

        return ATK_ROLE_PASSWORD_TEXT;

    return atkRole(axObject->roleValue());

}

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

{

    AccessibilityObject* parent = coreObject->parentObject();

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

    // Please keep the state list in alphabetical order

    if (coreObject->isChecked())

        atk_state_set_add_state(stateSet, ATK_STATE_CHECKED);

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

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

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

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

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

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

        !isListBoxOption)

        atk_state_set_add_state(stateSet, ATK_STATE_EDITABLE);

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

    if (coreObject->isEnabled()) {

        atk_state_set_add_state(stateSet, ATK_STATE_ENABLED);

        atk_state_set_add_state(stateSet, ATK_STATE_SENSITIVE);

    }

    if (coreObject->canSetFocusAttribute())

        atk_state_set_add_state(stateSet, ATK_STATE_FOCUSABLE);

    if (coreObject->isFocused())

        atk_state_set_add_state(stateSet, ATK_STATE_FOCUSED);

    // TODO: ATK_STATE_HORIZONTAL

    if (coreObject->isIndeterminate())

        atk_state_set_add_state(stateSet, ATK_STATE_INDETERMINATE);

    if (coreObject->isMultiSelectable())

        atk_state_set_add_state(stateSet, ATK_STATE_MULTISELECTABLE);

    // TODO: ATK_STATE_OPAQUE

    if (coreObject->isPressed())

        atk_state_set_add_state(stateSet, ATK_STATE_PRESSED);

    // TODO: ATK_STATE_SELECTABLE_TEXT

    if (coreObject->canSetSelectedAttribute()) {

        atk_state_set_add_state(stateSet, ATK_STATE_SELECTABLE);

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

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

        // former.

        if (isListBoxOption)

            atk_state_set_add_state(stateSet, ATK_STATE_FOCUSABLE);

    }

    if (coreObject->isSelected()) {

        atk_state_set_add_state(stateSet, ATK_STATE_SELECTED);

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

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

        // former.

        if (isListBoxOption)

            atk_state_set_add_state(stateSet, ATK_STATE_FOCUSED);

    }

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

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

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

    // issues with SHOWING vs VISIBLE within GTK+

    if (!coreObject->isOffScreen()) {

        atk_state_set_add_state(stateSet, ATK_STATE_SHOWING);

        atk_state_set_add_state(stateSet, ATK_STATE_VISIBLE);

    }

    // Mutually exclusive, so we group these two

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