/*

 * Copyright (C) 2008, 2009, 2010 Apple Inc. All Rights Reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

#include "config.h"

#include "WebKitDLL.h"

#include "AccessibleBase.h"

#include "AccessibleImage.h"

#include "WebView.h"

#include <WebCore/AccessibilityListBox.h>

#include <WebCore/AccessibilityMenuListPopup.h>

#include <WebCore/AccessibilityObject.h>

#include <WebCore/AXObjectCache.h>

#include <WebCore/BString.h>

#include <WebCore/Element.h>

#include <WebCore/EventHandler.h>

#include <WebCore/FrameView.h>

#include <WebCore/HostWindow.h>

#include <WebCore/HTMLNames.h>

#include <WebCore/HTMLFrameElementBase.h>

#include <WebCore/HTMLInputElement.h>

#include <WebCore/IntRect.h>

#include <WebCore/PlatformKeyboardEvent.h>

#include <WebCore/RenderFrame.h>

#include <WebCore/RenderObject.h>

#include <WebCore/RenderView.h>

#include <oleacc.h>

#include <wtf/RefPtr.h>

using namespace WebCore;

AccessibleBase::AccessibleBase(AccessibilityObject* obj)

    : AccessibilityObjectWrapper(obj)

    , m_refCount(0)

{

    ASSERT_ARG(obj, obj);

    m_object->setWrapper(this);

    ++gClassCount;

    gClassNameCount.add("AccessibleBase");

}

AccessibleBase::~AccessibleBase()

{

    --gClassCount;

    gClassNameCount.remove("AccessibleBase");

}

AccessibleBase* AccessibleBase::createInstance(AccessibilityObject* obj)

{

    ASSERT_ARG(obj, obj);

    if (obj->isImage())

        return new AccessibleImage(obj);

    return new AccessibleBase(obj);

}

HRESULT AccessibleBase::QueryService(REFGUID guidService, REFIID riid, void **ppvObject)

{

    if (!IsEqualGUID(guidService, SID_AccessibleComparable)) {

        *ppvObject = 0;

        return E_INVALIDARG;

    }

    return QueryInterface(riid, ppvObject);

}

// IUnknown

HRESULT STDMETHODCALLTYPE AccessibleBase::QueryInterface(REFIID riid, void** ppvObject)

{

    if (IsEqualGUID(riid, __uuidof(IAccessible)))

        *ppvObject = static_cast<IAccessible*>(this);

    else if (IsEqualGUID(riid, __uuidof(IDispatch)))

        *ppvObject = static_cast<IAccessible*>(this);

    else if (IsEqualGUID(riid, __uuidof(IUnknown)))

        *ppvObject = static_cast<IAccessible*>(this);

    else if (IsEqualGUID(riid, __uuidof(IAccessibleComparable)))

        *ppvObject = static_cast<IAccessibleComparable*>(this);

    else if (IsEqualGUID(riid, __uuidof(IServiceProvider)))

        *ppvObject = static_cast<IServiceProvider*>(this);

    else if (IsEqualGUID(riid, __uuidof(AccessibleBase)))

        *ppvObject = static_cast<AccessibleBase*>(this);

    else {

        *ppvObject = 0;

        return E_NOINTERFACE;

    }

    AddRef();

    return S_OK;

}

ULONG STDMETHODCALLTYPE AccessibleBase::Release(void)

{

    ASSERT(m_refCount > 0);

    if (--m_refCount)

        return m_refCount;

    delete this;

    return 0;

}

// IAccessible

HRESULT STDMETHODCALLTYPE AccessibleBase::get_accParent(IDispatch** parent)

{

    *parent = 0;

    if (!m_object)

        return E_FAIL;

    AccessibilityObject* parentObject = m_object->parentObjectUnignored();

    if (parentObject) {

        *parent = wrapper(parentObject);

        (*parent)->AddRef();

        return S_OK;

    }

    if (!m_object->topDocumentFrameView())

        return E_FAIL;

    return WebView::AccessibleObjectFromWindow(m_object->topDocumentFrameView()->hostWindow()->platformPageClient(),

        OBJID_WINDOW, __uuidof(IAccessible), reinterpret_cast<void**>(parent));

}

HRESULT STDMETHODCALLTYPE AccessibleBase::get_accChildCount(long* count)

{

    if (!m_object)

        return E_FAIL;

    if (!count)

        return E_POINTER;

    *count = static_cast<long>(m_object->children().size());

    return S_OK;

}

HRESULT STDMETHODCALLTYPE AccessibleBase::get_accChild(VARIANT vChild, IDispatch** ppChild)

{

    if (!ppChild)

        return E_POINTER;

    *ppChild = 0;

    AccessibilityObject* childObj;

    HRESULT hr = getAccessibilityObjectForChild(vChild, childObj);

    if (FAILED(hr))

        return hr;

    *ppChild = static_cast<IDispatch*>(wrapper(childObj));

    (*ppChild)->AddRef();

    return S_OK;

}

HRESULT STDMETHODCALLTYPE AccessibleBase::get_accName(VARIANT vChild, BSTR* name)

{

    if (!name)

        return E_POINTER;

    *name = 0;

    AccessibilityObject* childObj;

    HRESULT hr = getAccessibilityObjectForChild(vChild, childObj);

    if (FAILED(hr))

        return hr;

    if (*name = BString(wrapper(childObj)->name()).release())

        return S_OK;

    return S_FALSE;

}

HRESULT STDMETHODCALLTYPE AccessibleBase::get_accValue(VARIANT vChild, BSTR* value)

{

    if (!value)

        return E_POINTER;

    *value = 0;

    AccessibilityObject* childObj;

    HRESULT hr = getAccessibilityObjectForChild(vChild, childObj);

    if (FAILED(hr))

        return hr;

    if (*value = BString(wrapper(childObj)->value()).release())

        return S_OK;

    return S_FALSE;

}

HRESULT STDMETHODCALLTYPE AccessibleBase::get_accDescription(VARIANT vChild, BSTR* description)

{

    if (!description)

        return E_POINTER;

    *description = 0;

    AccessibilityObject* childObj;

    HRESULT hr = getAccessibilityObjectForChild(vChild, childObj);

    if (FAILED(hr))

        return hr;

    if (*description = BString(childObj->descriptionForMSAA()).release())

        return S_OK;

    return S_FALSE;

}

HRESULT STDMETHODCALLTYPE AccessibleBase::get_accRole(VARIANT vChild, VARIANT* pvRole)

{

    if (!pvRole)

        return E_POINTER;

    ::VariantInit(pvRole);

    AccessibilityObject* childObj;

    HRESULT hr = getAccessibilityObjectForChild(vChild, childObj);

    if (FAILED(hr))

        return hr;

    String roleString = childObj->stringRoleForMSAA();

    if (!roleString.isEmpty()) {

        V_VT(pvRole) = VT_BSTR;

        V_BSTR(pvRole) = BString(roleString).release();

        return S_OK;

    }

    pvRole->vt = VT_I4;

    pvRole->lVal = wrapper(childObj)->role();

    return S_OK;

}

HRESULT STDMETHODCALLTYPE AccessibleBase::get_accState(VARIANT vChild, VARIANT* pvState)

{

    if (!pvState)

        return E_POINTER;

    ::VariantInit(pvState);

    AccessibilityObject* childObj;

    HRESULT hr = getAccessibilityObjectForChild(vChild, childObj);

    if (FAILED(hr))

        return hr;

    pvState->vt = VT_I4;

    pvState->lVal = 0;

    if (childObj->isLinked())

        pvState->lVal |= STATE_SYSTEM_LINKED;

    if (childObj->isHovered())

        pvState->lVal |= STATE_SYSTEM_HOTTRACKED;

    if (!childObj->isEnabled())

        pvState->lVal |= STATE_SYSTEM_UNAVAILABLE;

    if (childObj->isReadOnly())

        pvState->lVal |= STATE_SYSTEM_READONLY;

    if (childObj->isOffScreen())

        pvState->lVal |= STATE_SYSTEM_OFFSCREEN;

    if (childObj->isPasswordField())

        pvState->lVal |= STATE_SYSTEM_PROTECTED;

    if (childObj->isIndeterminate())

        pvState->lVal |= STATE_SYSTEM_INDETERMINATE;

    if (childObj->isChecked())

        pvState->lVal |= STATE_SYSTEM_CHECKED;

    if (childObj->isPressed())

        pvState->lVal |= STATE_SYSTEM_PRESSED;

    if (childObj->isFocused())

        pvState->lVal |= STATE_SYSTEM_FOCUSED;

    if (childObj->isVisited())

        pvState->lVal |= STATE_SYSTEM_TRAVERSED;

    if (childObj->canSetFocusAttribute())

        pvState->lVal |= STATE_SYSTEM_FOCUSABLE;

    if (childObj->isSelected())

        pvState->lVal |= STATE_SYSTEM_SELECTED;

    if (childObj->canSetSelectedAttribute())

        pvState->lVal |= STATE_SYSTEM_SELECTABLE;

    if (childObj->isMultiSelectable())

        pvState->lVal |= STATE_SYSTEM_EXTSELECTABLE | STATE_SYSTEM_MULTISELECTABLE;

    if (!childObj->isVisible())

        pvState->lVal |= STATE_SYSTEM_INVISIBLE;

    if (childObj->isCollapsed())

        pvState->lVal |= STATE_SYSTEM_COLLAPSED;

    if (childObj->roleValue() == PopUpButtonRole) {

        pvState->lVal |= STATE_SYSTEM_HASPOPUP;

        if (!childObj->isCollapsed())

            pvState->lVal |= STATE_SYSTEM_EXPANDED;

    }

    return S_OK;

}

HRESULT STDMETHODCALLTYPE AccessibleBase::get_accHelp(VARIANT vChild, BSTR* helpText)

{

    if (!helpText)

        return E_POINTER;

    *helpText = 0;

    AccessibilityObject* childObj;

    HRESULT hr = getAccessibilityObjectForChild(vChild, childObj);

    if (FAILED(hr))

        return hr;

    if (*helpText = BString(childObj->helpText()).release())

        return S_OK;

    return S_FALSE;

}

HRESULT STDMETHODCALLTYPE AccessibleBase::get_accKeyboardShortcut(VARIANT vChild, BSTR* shortcut)

{

    if (!shortcut)

        return E_POINTER;

    *shortcut = 0;

    AccessibilityObject* childObj;

    HRESULT hr = getAccessibilityObjectForChild(vChild, childObj);

    if (FAILED(hr))

        return hr;

    String accessKey = childObj->accessKey();

    if (accessKey.isNull())

        return S_FALSE;

    static String accessKeyModifiers;

    if (accessKeyModifiers.isNull()) {

        unsigned modifiers = EventHandler::accessKeyModifiers();

        // Follow the same order as Mozilla MSAA implementation:

        // Ctrl+Alt+Shift+Meta+key. MSDN states that keyboard shortcut strings

        // should not be localized and defines the separator as "+".

        if (modifiers & PlatformKeyboardEvent::CtrlKey)

            accessKeyModifiers += "Ctrl+";

        if (modifiers & PlatformKeyboardEvent::AltKey)

            accessKeyModifiers += "Alt+";

        if (modifiers & PlatformKeyboardEvent::ShiftKey)

            accessKeyModifiers += "Shift+";

        if (modifiers & PlatformKeyboardEvent::MetaKey)

            accessKeyModifiers += "Win+";

    }

    *shortcut = BString(accessKeyModifiers + accessKey).release();

    return S_OK;

}

HRESULT STDMETHODCALLTYPE AccessibleBase::accSelect(long selectionFlags, VARIANT vChild)

{

    // According to MSDN, these combinations are invalid.

    if (((selectionFlags & (SELFLAG_ADDSELECTION | SELFLAG_REMOVESELECTION)) == (SELFLAG_ADDSELECTION | SELFLAG_REMOVESELECTION))

        || ((selectionFlags & (SELFLAG_ADDSELECTION | SELFLAG_TAKESELECTION)) == (SELFLAG_ADDSELECTION | SELFLAG_TAKESELECTION))

        || ((selectionFlags & (SELFLAG_REMOVESELECTION | SELFLAG_TAKESELECTION)) == (SELFLAG_REMOVESELECTION | SELFLAG_TAKESELECTION))

        || ((selectionFlags & (SELFLAG_EXTENDSELECTION | SELFLAG_TAKESELECTION)) == (SELFLAG_EXTENDSELECTION | SELFLAG_TAKESELECTION)))

        return E_INVALIDARG;

    AccessibilityObject* childObject;

    HRESULT hr = getAccessibilityObjectForChild(vChild, childObject);

    if (FAILED(hr))

        return hr;

    if (selectionFlags & SELFLAG_TAKEFOCUS)

        childObject->setFocused(true);

    AccessibilityObject* parentObject = childObject->parentObject();

    if (!parentObject)

        return E_INVALIDARG;

    if (selectionFlags & SELFLAG_TAKESELECTION) {

        if (parentObject->isListBox()) {

            Vector<RefPtr<AccessibilityObject> > selectedChildren(1);

            selectedChildren[0] = childObject;

            static_cast<AccessibilityListBox*>(parentObject)->setSelectedChildren(selectedChildren);

        } else { // any element may be selectable by virtue of it having the aria-selected property

            ASSERT(!parentObject->isMultiSelectable());

            childObject->setSelected(true);

        }

    }

    // MSDN says that ADD, REMOVE, and EXTENDSELECTION with no other flags are invalid for

    // single-select.

    const long allSELFLAGs = SELFLAG_TAKEFOCUS | SELFLAG_TAKESELECTION | SELFLAG_EXTENDSELECTION | SELFLAG_ADDSELECTION | SELFLAG_REMOVESELECTION;

    if (!parentObject->isMultiSelectable()

        && (((selectionFlags & allSELFLAGs) == SELFLAG_ADDSELECTION)

        || ((selectionFlags & allSELFLAGs) == SELFLAG_REMOVESELECTION)

        || ((selectionFlags & allSELFLAGs) == SELFLAG_EXTENDSELECTION)))

        return E_INVALIDARG;

    if (selectionFlags & SELFLAG_ADDSELECTION)

        childObject->setSelected(true);

    if (selectionFlags & SELFLAG_REMOVESELECTION)

        childObject->setSelected(false);

    // FIXME: Should implement SELFLAG_EXTENDSELECTION. For now, we just return

    // S_OK, matching Firefox.

    return S_OK;

}

HRESULT STDMETHODCALLTYPE AccessibleBase::get_accSelection(VARIANT*)

{

    return E_NOTIMPL;

}

HRESULT STDMETHODCALLTYPE AccessibleBase::get_accFocus(VARIANT* pvFocusedChild)

{

    if (!pvFocusedChild)

        return E_POINTER;

    ::VariantInit(pvFocusedChild);

    if (!m_object)

        return E_FAIL;

    AccessibilityObject* focusedObj = m_object->focusedUIElement();

    if (!focusedObj)

        return S_FALSE;

    if (focusedObj == m_object) {

        V_VT(pvFocusedChild) = VT_I4;

        V_I4(pvFocusedChild) = CHILDID_SELF;

        return S_OK;

    }

    V_VT(pvFocusedChild) = VT_DISPATCH;

    V_DISPATCH(pvFocusedChild) = wrapper(focusedObj);

    V_DISPATCH(pvFocusedChild)->AddRef();

    return S_OK;

}

HRESULT STDMETHODCALLTYPE AccessibleBase::get_accDefaultAction(VARIANT vChild, BSTR* action)

{

    if (!action)

        return E_POINTER;

    *action = 0;

    AccessibilityObject* childObj;

    HRESULT hr = getAccessibilityObjectForChild(vChild, childObj);

    if (FAILED(hr))

        return hr;

    if (*action = BString(childObj->actionVerb()).release())

        return S_OK;

    return S_FALSE;

}

HRESULT STDMETHODCALLTYPE AccessibleBase::accLocation(long* left, long* top, long* width, long* height, VARIANT vChild)

{

    if (!left || !top || !width || !height)

        return E_POINTER;

    *left = *top = *width = *height = 0;

    AccessibilityObject* childObj;

    HRESULT hr = getAccessibilityObjectForChild(vChild, childObj);

    if (FAILED(hr))

        return hr;

    if (!childObj->documentFrameView())

        return E_FAIL;

    IntRect screenRect(childObj->documentFrameView()->contentsToScreen(childObj->elementRect()));

    *left = screenRect.x();

    *top = screenRect.y();

    *width = screenRect.width();

    *height = screenRect.height();

    return S_OK;

}

HRESULT STDMETHODCALLTYPE AccessibleBase::accNavigate(long direction, VARIANT vFromChild, VARIANT* pvNavigatedTo)

{

    if (!pvNavigatedTo)

        return E_POINTER;

    ::VariantInit(pvNavigatedTo);

    AccessibilityObject* childObj = 0;

    switch (direction) {

        case NAVDIR_DOWN:

        case NAVDIR_UP:

        case NAVDIR_LEFT:

        case NAVDIR_RIGHT:

            // These directions are not implemented, matching Mozilla and IE.

            return E_NOTIMPL;

        case NAVDIR_LASTCHILD:

        case NAVDIR_FIRSTCHILD:

            // MSDN states that navigating to first/last child can only be from self.

            if (vFromChild.lVal != CHILDID_SELF)