/*

 * Copyright (C) 2004, 2005, 2006, 2007 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 COMPUTER, 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 COMPUTER, 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.

 */

#import "config.h"

#import "WebCoreAXObject.h"

#import "DOMInternal.h"

#import "ColorMac.h"

#import "Document.h"

#import "EventNames.h"

#import "FocusController.h"

#import "FontData.h"

#import "Frame.h"

#import "FrameLoader.h"

#import "FrameView.h"

#import "HTMLAreaElement.h"

#import "HTMLCollection.h"

#import "HTMLFrameElementBase.h"

#import "HTMLImageElement.h"

#import "HTMLInputElement.h"

#import "HTMLLabelElement.h"

#import "HTMLMapElement.h"

#import "HTMLNames.h"

#import "HTMLSelectElement.h"

#import "HTMLTextAreaElement.h"

#import "HitTestRequest.h"

#import "HitTestResult.h"

#import "LocalizedStrings.h"

#import "NodeList.h"

#import "Page.h"

#import "RenderImage.h"

#import "RenderListMarker.h"

#import "RenderMenuList.h"

#import "RenderTextControl.h"

#import "RenderTheme.h"

#import "RenderView.h"

#import "RenderWidget.h"

#import "SelectionController.h"

#import "TextIterator.h"

#import "WebCoreFrameBridge.h"

#import "WebCoreFrameView.h"

#import "WebCoreObjCExtras.h"

#import "WebCoreViewFactory.h"

#import "htmlediting.h"

#import "kjs_html.h"

#import "visible_units.h"

#include <mach-o/dyld.h>

using namespace WebCore;

using namespace EventNames;

using namespace HTMLNames;

@interface WebCoreAXObject (PrivateWebCoreAXObject)

// forward declarations as needed

- (WebCoreTextMarker*)textMarkerForIndex: (NSNumber*) index lastIndexOK: (BOOL)lastIndexOK;

- (id)doAXLineForTextMarker: (WebCoreTextMarker* ) textMarker;

@end

@implementation WebCoreAXObject

#ifndef BUILDING_ON_TIGER

+ (void)initialize

{

    WebCoreObjCFinalizeOnMainThread(self);

}

#endif

-(id)initWithRenderer:(RenderObject*)renderer

{

    [super init];

    m_renderer = renderer;

    return self;

}

-(BOOL)detached

{

    return !m_renderer;

}

-(void)detach

{

    // Send unregisterUniqueIdForUIElement unconditionally because if it is

    // ever accidently not done (via other bugs in our AX implementation) you

    // end up with a crash like <rdar://problem/4273149>.  It is safe and not

    // expensive to send even if the object is not registered.

    [[WebCoreViewFactory sharedFactory] unregisterUniqueIdForUIElement:self];

    [m_data release];

    m_data = 0;

    [self removeAXObjectID];

    m_renderer = 0;

    [self clearChildren];

}

- (void)dealloc

{

    [self detach];

    [super dealloc];

}

- (void)finalize

{

    [self detach];

    [super finalize];

}

-(id)data

{

    return m_data;

}

-(void)setData:(id)data

{

    if (!m_renderer)

        return;

    [data retain];

    [m_data release];

    m_data = data;

}

-(HTMLAnchorElement*)anchorElement

{

    // return already-known anchor for image areas

    if (m_areaElement)

        return m_areaElement;

    // search up the render tree for a RenderObject with a DOM node.  Defer to an earlier continuation, though.

    RenderObject* currRenderer;

    for (currRenderer = m_renderer; currRenderer && !currRenderer->element(); currRenderer = currRenderer->parent()) {

        if (currRenderer->continuation())

            return [currRenderer->document()->axObjectCache()->get(currRenderer->continuation()) anchorElement];

    }

    // bail of none found

    if (!currRenderer)

        return 0;

    // search up the DOM tree for an anchor element

    // NOTE: this assumes that any non-image with an anchor is an HTMLAnchorElement

    Node* elt = currRenderer->element();

    for ( ; elt; elt = elt->parentNode()) {

        if (elt->isLink() && elt->renderer() && !elt->renderer()->isImage())

            return static_cast<HTMLAnchorElement*>(elt);

    }

    return 0;

}

-(BOOL)isImageButton

{

    return m_renderer->isImage() && m_renderer->element() && m_renderer->element()->hasTagName(inputTag);

}

-(Element*)mouseButtonListener

{

    // FIXME: Do the continuation search like anchorElement does

    for (EventTargetNode* elt = static_cast<EventTargetNode*>(m_renderer->element()); elt; elt = static_cast<EventTargetNode*>(elt->parentNode())) {

        if (elt->getHTMLEventListener(clickEvent) || elt->getHTMLEventListener(mousedownEvent) || elt->getHTMLEventListener(mouseupEvent))

            return static_cast<Element*>(elt);

    }

    return 0;

}

-(Element*)actionElement

{

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

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

        if (!input->disabled() && (input->inputType() == HTMLInputElement::CHECKBOX ||

                                   input->inputType() == HTMLInputElement::RADIO ||

                                   input->isTextButton()))

            return input;

    }

    if ([self isImageButton] || m_renderer->isMenuList())

        return static_cast<Element*>(m_renderer->element());

    Element* elt = [self anchorElement];

    if (!elt)

        elt = [self mouseButtonListener];

    return elt;

}

-(WebCoreAXObject*)firstChild

{

    if (!m_renderer || !m_renderer->firstChild())

        return nil;

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

}

-(WebCoreAXObject*)lastChild

{

    if (!m_renderer || !m_renderer->lastChild())

        return nil;

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

}

-(WebCoreAXObject*)previousSibling

{

    if (!m_renderer || !m_renderer->previousSibling())

        return nil;

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

}

-(WebCoreAXObject*)nextSibling

{

    if (!m_renderer || !m_renderer->nextSibling())

        return nil;

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

}

-(WebCoreAXObject*)parentObject

{

    if (m_areaElement)

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

    if (!m_renderer || !m_renderer->parent())

        return nil;

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

}

-(WebCoreAXObject*)parentObjectUnignored

{

    WebCoreAXObject* obj = [self parentObject];

    if ([obj accessibilityIsIgnored])

        return [obj parentObjectUnignored];

    return obj;

}

-(void)addChildrenToArray:(NSMutableArray*)array

{

    // nothing to add if there is no RenderObject

    if (!m_renderer)

        return;

    // try to add RenderWidget's children, but fall thru if there are none

    if (m_renderer->isWidget()) {

        RenderWidget* renderWidget = static_cast<RenderWidget*>(m_renderer);

        Widget* widget = renderWidget->widget();

        if (widget) {

            NSArray* childArr = [(widget->getOuterView()) accessibilityAttributeValue: NSAccessibilityChildrenAttribute];

            [array addObjectsFromArray: childArr];

            return;

        }

    }

    // add all unignored acc children

    for (WebCoreAXObject* obj = [self firstChild]; obj; obj = [obj nextSibling]) {

        if ([obj accessibilityIsIgnored])

            [obj addChildrenToArray: array];

        else

            [array addObject: obj];

    }

    // for a RenderImage, add the <area> elements as individual accessibility objects

    if (m_renderer->isImage() && !m_areaElement) {

        HTMLMapElement* map = static_cast<RenderImage*>(m_renderer)->imageMap();

        if (map) {

            for (Node* current = map->firstChild(); current; current = current->traverseNextNode(map)) {

                // add an <area> element for this child if it has a link

                // NOTE: can't cache these because they all have the same renderer, which is the cache key, right?

                // plus there may be little reason to since they are being added to the handy array

                if (current->isLink()) {

                    WebCoreAXObject* obj = [[[WebCoreAXObject alloc] initWithRenderer: m_renderer] autorelease];

                    obj->m_areaElement = static_cast<HTMLAreaElement*>(current);

                    [array addObject: obj];

                }

            }

        }

    }

}

-(BOOL)isWebArea

{

    return m_renderer->isRenderView();

}

-(BOOL)isAnchor

{

    return m_areaElement || (!m_renderer->isImage() && m_renderer->element() && m_renderer->element()->isLink());

} 

-(BOOL)isTextControl

{

    return m_renderer->isTextField() || m_renderer->isTextArea();

}

static bool isPasswordFieldElement(Node* node)

{

    if (!node || !node->hasTagName(inputTag))

        return false;

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

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

}

-(BOOL)isPasswordField

{

    return m_renderer && isPasswordFieldElement(m_renderer->element());

}

-(BOOL)isAttachment

{

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

    BOOL result = m_renderer && m_renderer->isWidget();

    // assert that a widget is a replaced element that is not an image

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

    return result;

}

-(NSView*)attachmentView

{

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

    RenderWidget* renderWidget = static_cast<RenderWidget*>(m_renderer);

    Widget* widget = renderWidget->widget();

    if (widget)

         return widget->getView();

    return nil;

}

static int blockquoteLevel(RenderObject* renderer)

{

    int result = 0;

    for (Node* node = renderer->element(); node; node = node->parent()) {

        if (node->hasTagName(blockquoteTag))

            result += 1;

    }

    return result;

}

static int headingLevel(RenderObject* renderer)

{

    if (!renderer->isBlockFlow())

        return 0;

    Node* node = renderer->element();

    if (!node)

        return 0;

    if (node->hasTagName(h1Tag))

        return 1;

    if (node->hasTagName(h2Tag))

        return 2;

    if (node->hasTagName(h3Tag))

        return 3;

    if (node->hasTagName(h4Tag))

        return 4;

    if (node->hasTagName(h5Tag))

        return 5;

    if (node->hasTagName(h6Tag))

        return 6;

    return 0;

}

-(int)headingLevel

{

    return headingLevel(m_renderer);

}

-(BOOL)isHeading

{

    return [self headingLevel] != 0;

}

-(NSString*)role

{

    if (!m_renderer)

        return NSAccessibilityUnknownRole;

    if (m_areaElement)

        return @"AXLink";

    if (m_renderer->element() && m_renderer->element()->isLink()) {

        if (m_renderer->isImage())

            return @"AXImageMap";

        return @"AXLink";

    }

    if (m_renderer->isListMarker())

        return @"AXListMarker";

    if (m_renderer->element() && m_renderer->element()->hasTagName(buttonTag))

        return NSAccessibilityButtonRole;

    if (m_renderer->isText())

        return NSAccessibilityStaticTextRole;

    if (m_renderer->isImage()) {

        if ([self isImageButton])

            return NSAccessibilityButtonRole;

        return NSAccessibilityImageRole;

    }

    if ([self isWebArea])

        return @"AXWebArea";

    if (m_renderer->isTextField())

        return NSAccessibilityTextFieldRole;

    if (m_renderer->isTextArea())

        return NSAccessibilityTextAreaRole;

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

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

        if (input->inputType() == HTMLInputElement::CHECKBOX)

            return NSAccessibilityCheckBoxRole;

        if (input->inputType() == HTMLInputElement::RADIO)

            return NSAccessibilityRadioButtonRole;

        if (input->isTextButton())

            return NSAccessibilityButtonRole;

    }

    if (m_renderer->isMenuList())

        return NSAccessibilityPopUpButtonRole;

    if ([self isHeading])

        return @"AXHeading";

    if (m_renderer->isBlockFlow())

        return NSAccessibilityGroupRole;

    if ([self isAttachment])

        return [[self attachmentView] accessibilityAttributeValue:NSAccessibilityRoleAttribute];

    return NSAccessibilityUnknownRole;

}

-(NSString*)subrole

{

    if ([self isPasswordField])

        return NSAccessibilitySecureTextFieldSubrole;

    if ([self isAttachment]) {

        NSView* attachmentView = [self attachmentView];

        if ([[attachmentView accessibilityAttributeNames] containsObject:NSAccessibilitySubroleAttribute]) {

            return [attachmentView accessibilityAttributeValue:NSAccessibilitySubroleAttribute];

        }

    }

    return nil;

}

-(NSString*)roleDescription

{

    if (!m_renderer)

        return nil;

    // attachments have the AXImage role, but a different subrole

    if ([self isAttachment])

        return [[self attachmentView] accessibilityAttributeValue:NSAccessibilityRoleDescriptionAttribute];

    // FIXME 3447564: It would be better to call some AppKit API to get these strings

    // (which would be the best way to localize them)

    NSString* role = [self role];

    if ([role isEqualToString:NSAccessibilityButtonRole])

        return NSAccessibilityRoleDescription(NSAccessibilityButtonRole, [self subrole]);

    if ([role isEqualToString:NSAccessibilityPopUpButtonRole])

        return NSAccessibilityRoleDescription(NSAccessibilityPopUpButtonRole, [self subrole]);

    if ([role isEqualToString:NSAccessibilityStaticTextRole])

        return NSAccessibilityRoleDescription(NSAccessibilityStaticTextRole, [self subrole]);

    if ([role isEqualToString:NSAccessibilityImageRole])

        return NSAccessibilityRoleDescription(NSAccessibilityImageRole, [self subrole]);

    if ([role isEqualToString:NSAccessibilityGroupRole])

        return NSAccessibilityRoleDescription(NSAccessibilityGroupRole, [self subrole]);

    if ([role isEqualToString:NSAccessibilityCheckBoxRole])

        return NSAccessibilityRoleDescription(NSAccessibilityCheckBoxRole, [self subrole]);

    if ([role isEqualToString:NSAccessibilityRadioButtonRole])

        return NSAccessibilityRoleDescription(NSAccessibilityRadioButtonRole, [self subrole]);

    if ([role isEqualToString:NSAccessibilityTextFieldRole])

        return NSAccessibilityRoleDescription(NSAccessibilityTextFieldRole, [self subrole]);

    if ([role isEqualToString:NSAccessibilityTextAreaRole])

        return NSAccessibilityRoleDescription(NSAccessibilityTextAreaRole, [self subrole]);

    if ([role isEqualToString:@"AXWebArea"])

        return AXWebAreaText();

    if ([role isEqualToString:@"AXLink"])

        return AXLinkText();

    if ([role isEqualToString:@"AXListMarker"])

        return AXListMarkerText();

    if ([role isEqualToString:@"AXImageMap"])

        return AXImageMapText();

    if ([role isEqualToString:@"AXHeading"])

        return AXHeadingText();