/*

* Copyright (C) 2008 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.

* 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of

*     its contributors may be used to endorse or promote products derived

*     from this software without specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "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 OR ITS 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 "AccessibilityRenderObject.h"

#include "AXObjectCache.h"

#include "AccessibilityImageMapLink.h"

#include "AccessibilityListBox.h"

#include "CharacterNames.h"

#include "EventNames.h"

#include "FloatRect.h"

#include "Frame.h"

#include "FrameLoader.h"

#include "HTMLAreaElement.h"

#include "HTMLFormElement.h"

#include "HTMLFrameElementBase.h"

#include "HTMLImageElement.h"

#include "HTMLInputElement.h"

#include "HTMLLabelElement.h"

#include "HTMLMapElement.h"

#include "HTMLOptGroupElement.h"

#include "HTMLOptionElement.h"

#include "HTMLOptionsCollection.h"

#include "HTMLSelectElement.h"

#include "HTMLTextAreaElement.h"

#include "HitTestRequest.h"

#include "HitTestResult.h"

#include "LocalizedStrings.h"

#include "NodeList.h"

#include "ProgressTracker.h"

#include "RenderButton.h"

#include "RenderFieldset.h"

#include "RenderFileUploadControl.h"

#include "RenderHTMLCanvas.h"

#include "RenderImage.h"

#include "RenderInline.h"

#include "RenderLayer.h"

#include "RenderListBox.h"

#include "RenderListMarker.h"

#include "RenderMenuList.h"

#include "RenderText.h"

#include "RenderTextControl.h"

#include "RenderTextFragment.h"

#include "RenderTheme.h"

#include "RenderView.h"

#include "RenderWidget.h"

#include "SelectElement.h"

#include "SelectionController.h"

#include "Text.h"

#include "TextIterator.h"

#include "htmlediting.h"

#include "visible_units.h"

#include <wtf/StdLibExtras.h>

using namespace std;

namespace WebCore {

using namespace HTMLNames;

AccessibilityRenderObject::AccessibilityRenderObject(RenderObject* renderer)

    : AccessibilityObject()

    , m_renderer(renderer)

    , m_ariaRole(UnknownRole)

    , m_childrenDirty(false)

    , m_roleForMSAA(UnknownRole)

{

    m_role = determineAccessibilityRole();

#ifndef NDEBUG

    m_renderer->setHasAXObject(true);

#endif

}

AccessibilityRenderObject::~AccessibilityRenderObject()

{

    ASSERT(isDetached());

}

PassRefPtr<AccessibilityRenderObject> AccessibilityRenderObject::create(RenderObject* renderer)

{

    return adoptRef(new AccessibilityRenderObject(renderer));

}

void AccessibilityRenderObject::detach()

{

    clearChildren();

    AccessibilityObject::detach();

#ifndef NDEBUG

    if (m_renderer)

        m_renderer->setHasAXObject(false);

#endif

    m_renderer = 0;    

}

static inline bool isInlineWithContinuation(RenderObject* renderer)

{

    if (!renderer->isRenderInline())

        return false;

    return toRenderInline(renderer)->continuation();

}

static inline RenderObject* firstChildInContinuation(RenderObject* renderer)

{

    RenderObject* r = toRenderInline(renderer)->continuation();

    while (r) {

        if (r->isRenderBlock())

            return r;

        if (RenderObject* child = r->firstChild())

            return child;

        r = toRenderInline(r)->continuation(); 

    }

    return 0;

}

static inline RenderObject* firstChildConsideringContinuation(RenderObject* renderer)

{

    RenderObject* firstChild = renderer->firstChild();

    if (!firstChild && isInlineWithContinuation(renderer))

        firstChild = firstChildInContinuation(renderer);

    return firstChild;

}

static inline RenderObject* lastChildConsideringContinuation(RenderObject* renderer)

{

    RenderObject* lastChild = renderer->lastChild();

    RenderObject* prev;

    RenderObject* cur = renderer;

    if (!cur->isRenderInline() && !cur->isRenderBlock())

        return renderer;

    while (cur) {

        prev = cur;

        if (RenderObject* lc = cur->lastChild())

            lastChild = lc;

        if (cur->isRenderInline()) {

            cur = toRenderInline(cur)->inlineElementContinuation();

            ASSERT(cur || !toRenderInline(prev)->continuation());

        } else

            cur = toRenderBlock(cur)->inlineElementContinuation();

    }

    return lastChild;

}

AccessibilityObject* AccessibilityRenderObject::firstChild() const

{

    if (!m_renderer)

        return 0;

    RenderObject* firstChild = firstChildConsideringContinuation(m_renderer);

    if (!firstChild)

        return 0;

    return m_renderer->document()->axObjectCache()->getOrCreate(firstChild);

}

AccessibilityObject* AccessibilityRenderObject::lastChild() const

{

    if (!m_renderer)

        return 0;

    RenderObject* lastChild = lastChildConsideringContinuation(m_renderer);

    if (!lastChild)

        return 0;

    return m_renderer->document()->axObjectCache()->getOrCreate(lastChild);

}

static inline RenderInline* startOfContinuations(RenderObject* r)

{

    if (r->isInlineElementContinuation())

        return toRenderInline(r->node()->renderer());

    // Blocks with a previous continuation always have a next continuation

    if (r->isRenderBlock() && toRenderBlock(r)->inlineElementContinuation())

        return toRenderInline(toRenderBlock(r)->inlineElementContinuation()->node()->renderer());

    return 0;

}

static inline RenderObject* endOfContinuations(RenderObject* renderer)

{

    RenderObject* prev = renderer;

    RenderObject* cur = renderer;

    if (!cur->isRenderInline() && !cur->isRenderBlock())

        return renderer;

    while (cur) {

        prev = cur;

        if (cur->isRenderInline()) {

            cur = toRenderInline(cur)->inlineElementContinuation();

            ASSERT(cur || !toRenderInline(prev)->continuation());

        } else 

            cur = toRenderBlock(cur)->inlineElementContinuation();

    }

    return prev;

}

static inline RenderObject* childBeforeConsideringContinuations(RenderInline* r, RenderObject* child)

{

    RenderBoxModelObject* curContainer = r;

    RenderObject* cur = 0;

    RenderObject* prev = 0;

    while (curContainer) {

        if (curContainer->isRenderInline()) {

            cur = curContainer->firstChild();

            while (cur) {

                if (cur == child)

                    return prev;

                prev = cur;

                cur = cur->nextSibling();

            }

            curContainer = toRenderInline(curContainer)->continuation();

        } else if (curContainer->isRenderBlock()) {

            if (curContainer == child)

                return prev;

            prev = curContainer;

            curContainer = toRenderBlock(curContainer)->inlineElementContinuation();

        }

    }

    ASSERT_NOT_REACHED();

    return 0;

}

static inline bool firstChildIsInlineContinuation(RenderObject* renderer)

{

    return renderer->firstChild() && renderer->firstChild()->isInlineElementContinuation();

}

AccessibilityObject* AccessibilityRenderObject::previousSibling() const

{

    if (!m_renderer)

        return 0;

    RenderObject* previousSibling = 0;

    // Case 1: The node is a block and is an inline's continuation. In that case, the inline's

    // last child is our previous sibling (or further back in the continuation chain)

    RenderInline* startOfConts;

    if (m_renderer->isRenderBlock() && (startOfConts = startOfContinuations(m_renderer)))

        previousSibling = childBeforeConsideringContinuations(startOfConts, m_renderer);

    // Case 2: Anonymous block parent of the end of a continuation - skip all the way to before

    // the parent of the start, since everything in between will be linked up via the continuation.

    else if (m_renderer->isAnonymousBlock() && firstChildIsInlineContinuation(m_renderer))

        previousSibling = startOfContinuations(m_renderer->firstChild())->parent()->previousSibling();

    // Case 3: The node has an actual previous sibling

    else if (RenderObject* ps = m_renderer->previousSibling())

        previousSibling = ps;

    // Case 4: This node has no previous siblings, but its parent is an inline,

    // and is another node's inline continutation. Follow the continuation chain.

    else if (m_renderer->parent()->isRenderInline() && (startOfConts = startOfContinuations(m_renderer->parent())))

        previousSibling = childBeforeConsideringContinuations(startOfConts, m_renderer->parent()->firstChild());

    if (!previousSibling)

        return 0;

    return m_renderer->document()->axObjectCache()->getOrCreate(previousSibling);

}

static inline bool lastChildHasContinuation(RenderObject* renderer)

{

    return renderer->lastChild() && isInlineWithContinuation(renderer->lastChild());

}

AccessibilityObject* AccessibilityRenderObject::nextSibling() const

{

    if (!m_renderer)

        return 0;

    RenderObject* nextSibling = 0;

    // Case 1: node is a block and has an inline continuation. Next sibling is the inline continuation's

    // first child.

    RenderInline* inlineContinuation;

    if (m_renderer->isRenderBlock() && (inlineContinuation = toRenderBlock(m_renderer)->inlineElementContinuation()))

        nextSibling = firstChildConsideringContinuation(inlineContinuation);

    // Case 2: Anonymous block parent of the start of a continuation - skip all the way to

    // after the parent of the end, since everything in between will be linked up via the continuation.

    else if (m_renderer->isAnonymousBlock() && lastChildHasContinuation(m_renderer))

        nextSibling = endOfContinuations(m_renderer->lastChild())->parent()->nextSibling();

    // Case 3: node has an actual next sibling

    else if (RenderObject* ns = m_renderer->nextSibling())

        nextSibling = ns;

    // Case 4: node is an inline with a continuation. Next sibling is the next sibling of the end 

    // of the continuation chain.

    else if (isInlineWithContinuation(m_renderer))

        nextSibling = endOfContinuations(m_renderer)->nextSibling();

    // Case 5: node has no next sibling, and its parent is an inline with a continuation.

    else if (isInlineWithContinuation(m_renderer->parent())) {

        RenderObject* continuation = toRenderInline(m_renderer->parent())->continuation();

        // Case 4a: continuation is a block - in this case the block itself is the next sibling.

        if (continuation->isRenderBlock())

            nextSibling = continuation;

        // Case 4b: continuation is an inline - in this case the inline's first child is the next sibling

        else

            nextSibling = firstChildConsideringContinuation(continuation);

    }

    if (!nextSibling)

        return 0;

    return m_renderer->document()->axObjectCache()->getOrCreate(nextSibling);

}

AccessibilityObject* AccessibilityRenderObject::parentObjectIfExists() const

{

    if (!m_renderer)

        return 0;

    RenderObject* parent = m_renderer->parent();

    // Case 1: node is a block and is an inline's continuation. Parent

    // is the start of the continuation chain.

    RenderInline* startOfConts = 0;

    if (m_renderer->isRenderBlock() && (startOfConts = startOfContinuations(m_renderer)))

        parent = startOfConts;

    // Case 2: node's parent is an inline which is some node's continuation; parent is 

    // the earliest node in the continuation chain.

    else if (parent && parent->isRenderInline() && (startOfConts = startOfContinuations(parent)))

        parent = startOfConts;

    if (!parent)

        return 0;

    return m_renderer->document()->axObjectCache()->get(parent);

}

AccessibilityObject* AccessibilityRenderObject::parentObject() const

{

    if (!m_renderer)

        return 0;

    RenderObject* parent = m_renderer->parent();

    // Case 1: node is a block and is an inline's continuation. Parent

    // is the start of the continuation chain.

    RenderInline* startOfConts = 0;

    if (m_renderer->isRenderBlock() && (startOfConts = startOfContinuations(m_renderer)))

        parent = startOfConts;

    // Case 2: node's parent is an inline which is some node's continuation; parent is 

    // the earliest node in the continuation chain.

    else if (parent && parent->isRenderInline() && (startOfConts = startOfContinuations(parent)))

        parent = startOfConts;

    if (!parent)

        return 0;

    if (ariaRoleAttribute() == MenuBarRole)

        return m_renderer->document()->axObjectCache()->getOrCreate(parent);

    // menuButton and its corresponding menu are DOM siblings, but Accessibility needs them to be parent/child

    if (ariaRoleAttribute() == MenuRole) {

        AccessibilityObject* parent = menuButtonForMenu();

        if (parent)

            return parent;

    }

    return m_renderer->document()->axObjectCache()->getOrCreate(parent);

}

bool AccessibilityRenderObject::isWebArea() const

{

    return roleValue() == WebAreaRole;

}

bool AccessibilityRenderObject::isImageButton() const

{

    return isNativeImage() && roleValue() == ButtonRole;

}

bool AccessibilityRenderObject::isAnchor() const

{

    return !isNativeImage() && isLink();

}

bool AccessibilityRenderObject::isNativeTextControl() const

{

    return m_renderer->isTextControl();

}

bool AccessibilityRenderObject::isTextControl() const

{

    AccessibilityRole role = roleValue();

    return role == TextAreaRole || role == TextFieldRole;

}

bool AccessibilityRenderObject::isNativeImage() const

{

    return m_renderer->isImage();

}    

bool AccessibilityRenderObject::isImage() const

{

    return roleValue() == ImageRole;

}

bool AccessibilityRenderObject::isAttachment() const

{

    if (!m_renderer)

        return false;

    // Widgets are the replaced elements that we represent to AX as attachments

    bool isWidget = m_renderer && m_renderer->isWidget();

    ASSERT(!isWidget || (m_renderer->isReplaced() && !isImage()));

    return isWidget && ariaRoleAttribute() == UnknownRole;

}

bool AccessibilityRenderObject::isPasswordField() const

{

    ASSERT(m_renderer);

    if (!m_renderer->node() || !m_renderer->node()->isHTMLElement())

        return false;

    if (ariaRoleAttribute() != UnknownRole)

        return false;

    InputElement* inputElement = toInputElement(static_cast<Element*>(m_renderer->node()));

    if (!inputElement)

        return false;

    return inputElement->isPasswordField();

}

bool AccessibilityRenderObject::isFileUploadButton() const

{

    if (m_renderer && m_renderer->node() && m_renderer->node()->hasTagName(inputTag)) {

        HTMLInputElement* input = static_cast<HTMLInputElement*>(m_renderer->node());

        return input->inputType() == HTMLInputElement::FILE;

    }

    return false;

}

bool AccessibilityRenderObject::isInputImage() const

{

    if (m_renderer && m_renderer->node() && m_renderer->node()->hasTagName(inputTag)) {

        HTMLInputElement* input = static_cast<HTMLInputElement*>(m_renderer->node());

        return input->inputType() == HTMLInputElement::IMAGE;

    }

    return false;

}

bool AccessibilityRenderObject::isProgressIndicator() const

{

    return roleValue() == ProgressIndicatorRole;

}

bool AccessibilityRenderObject::isSlider() const

{

    return roleValue() == SliderRole;

}

bool AccessibilityRenderObject::isMenuRelated() const

{

    AccessibilityRole role = roleValue();

    return role == MenuRole 

        || role == MenuBarRole

        || role == MenuButtonRole

        || role == MenuItemRole;

}    

bool AccessibilityRenderObject::isMenu() const

{

    return roleValue() == MenuRole;

}

bool AccessibilityRenderObject::isMenuBar() const

{

    return roleValue() == MenuBarRole;

}