Changeset 64874 in webkit


Ignore:
Timestamp:
Aug 6, 2010 3:20:36 PM (14 years ago)
Author:
eric@webkit.org
Message:

2010-08-06 Eric Seidel <​eric@webkit.org>

Reviewed by Chris Fleizach.

Make AX Code use more specific RenderObject subclass types
​https://bugs.webkit.org/show_bug.cgi?id=43632

No functional change, thus no tests.

  • accessibility/AXObjectCache.cpp: (WebCore::nodeHasRole):
    • Make this take a String instead of AtomicString, to avoid thrashing the atomic string hash. It would be better to take a const char* here, except one caller passes nullAtom.

(WebCore::createFromRenderer):

  • Split this out from getOrCreate to make it simpler.
  • No longer needs to deal with setting a "result" pointer and can instead just return.
  • I've also made this function use RenderBoxModelObject* where appropriate.

(WebCore::AXObjectCache::getOrCreate):

  • accessibility/AXObjectCache.h:
  • accessibility/AccessibilityImageMapLink.cpp: (WebCore::AccessibilityImageMapLink::AccessibilityImageMapLink):
    • Fix style.
  • accessibility/AccessibilityMenuList.cpp: (WebCore::AccessibilityMenuList::AccessibilityMenuList):
    • Use a more specific type.

(WebCore::AccessibilityMenuList::renderer):

  • accessibility/AccessibilityMenuList.h: (WebCore::AccessibilityMenuList::create):
  • accessibility/AccessibilityMenuListPopup.cpp:
    • Need RenderMenuList.h since renderer() is a RenderMenuList*
  • accessibility/AccessibilityObject.cpp: (WebCore::renderListItemContainerForNode):
  • accessibility/AccessibilityRenderObject.cpp: (WebCore::AccessibilityRenderObject::renderBoxModelObject):
    • New helper function, similar to Node::renderBoxModelObject()

(WebCore::isInlineWithContinuation):
(WebCore::AccessibilityRenderObject::isNativeImage):
(WebCore::AccessibilityRenderObject::isAttachment):
(WebCore::AccessibilityRenderObject::isMultiSelectable):
(WebCore::AccessibilityRenderObject::isReadOnly):
(WebCore::AccessibilityRenderObject::isFieldset):
(WebCore::AccessibilityRenderObject::actionElement):
(WebCore::AccessibilityRenderObject::stringValue):
(WebCore::AccessibilityRenderObject::accessibilityIsIgnored):
(WebCore::AccessibilityRenderObject::setValue):
(WebCore::AccessibilityRenderObject::widget):
(WebCore::AccessibilityRenderObject::visiblePositionForPoint):
(WebCore::AccessibilityRenderObject::doAccessibilityHitTest):
(WebCore::AccessibilityRenderObject::renderObjectIsObservable):
(WebCore::AccessibilityRenderObject::determineAccessibilityRole):
(WebCore::AccessibilityRenderObject::addChildren):
(WebCore::msaaRoleForRenderer):

  • accessibility/AccessibilityRenderObject.h:
  • accessibility/AccessibilityTable.cpp: (WebCore::AccessibilityTable::isTableExposableThroughAccessibility):
  • accessibility/AccessibilityTable.h:
    • Remove unneeded "using namespace std".
Location:
trunk/WebCore
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r64873 r64874  
     12010-08-06  Eric Seidel  <eric@webkit.org>
     2
     3        Reviewed by Chris Fleizach.
     4
     5        Make AX Code use more specific RenderObject subclass types
     6        https://bugs.webkit.org/show_bug.cgi?id=43632
     7
     8        No functional change, thus no tests.
     9
     10        * accessibility/AXObjectCache.cpp:
     11        (WebCore::nodeHasRole):
     12         - Make this take a String instead of AtomicString, to avoid
     13           thrashing the atomic string hash.
     14           It would be better to take a const char* here, except
     15           one caller passes nullAtom.
     16        (WebCore::createFromRenderer):
     17         - Split this out from getOrCreate to make it simpler.
     18         - No longer needs to deal with setting a "result"
     19           pointer and can instead just return.
     20         - I've also made this function use RenderBoxModelObject*
     21           where appropriate.
     22        (WebCore::AXObjectCache::getOrCreate):
     23        * accessibility/AXObjectCache.h:
     24        * accessibility/AccessibilityImageMapLink.cpp:
     25        (WebCore::AccessibilityImageMapLink::AccessibilityImageMapLink):
     26         - Fix style.
     27        * accessibility/AccessibilityMenuList.cpp:
     28        (WebCore::AccessibilityMenuList::AccessibilityMenuList):
     29         - Use a more specific type.
     30        (WebCore::AccessibilityMenuList::renderer):
     31        * accessibility/AccessibilityMenuList.h:
     32        (WebCore::AccessibilityMenuList::create):
     33        * accessibility/AccessibilityMenuListPopup.cpp:
     34         - Need RenderMenuList.h since renderer() is a RenderMenuList*
     35        * accessibility/AccessibilityObject.cpp:
     36        (WebCore::renderListItemContainerForNode):
     37        * accessibility/AccessibilityRenderObject.cpp:
     38        (WebCore::AccessibilityRenderObject::renderBoxModelObject):
     39         - New helper function, similar to Node::renderBoxModelObject()
     40        (WebCore::isInlineWithContinuation):
     41        (WebCore::AccessibilityRenderObject::isNativeImage):
     42        (WebCore::AccessibilityRenderObject::isAttachment):
     43        (WebCore::AccessibilityRenderObject::isMultiSelectable):
     44        (WebCore::AccessibilityRenderObject::isReadOnly):
     45        (WebCore::AccessibilityRenderObject::isFieldset):
     46        (WebCore::AccessibilityRenderObject::actionElement):
     47        (WebCore::AccessibilityRenderObject::stringValue):
     48        (WebCore::AccessibilityRenderObject::accessibilityIsIgnored):
     49        (WebCore::AccessibilityRenderObject::setValue):
     50        (WebCore::AccessibilityRenderObject::widget):
     51        (WebCore::AccessibilityRenderObject::visiblePositionForPoint):
     52        (WebCore::AccessibilityRenderObject::doAccessibilityHitTest):
     53        (WebCore::AccessibilityRenderObject::renderObjectIsObservable):
     54        (WebCore::AccessibilityRenderObject::determineAccessibilityRole):
     55        (WebCore::AccessibilityRenderObject::addChildren):
     56        (WebCore::msaaRoleForRenderer):
     57        * accessibility/AccessibilityRenderObject.h:
     58        * accessibility/AccessibilityTable.cpp:
     59        (WebCore::AccessibilityTable::isTableExposableThroughAccessibility):
     60        * accessibility/AccessibilityTable.h:
     61         - Remove unneeded "using namespace std".
     62
    1632010-08-06  Tony Gentilcore  <tonyg@chromium.org>
    264

  • trunk/WebCore/accessibility/AXObjectCache.cpp

    r61595 r64874  
    6060#include "InputElement.h"
    6161#include "Page.h"
    62 #include "RenderObject.h"
     62#include "RenderListBox.h"
     63#include "RenderMenuList.h"
     64#include "RenderTable.h"
     65#include "RenderTableCell.h"
     66#include "RenderTableRow.h"
    6367#include "RenderProgress.h"
     68#include "RenderSlider.h"
    6469#include "RenderView.h"
    6570
    … …  
    161166    return obj;
    162167}
    163    
    164 bool AXObjectCache::nodeHasRole(Node* node, const AtomicString& role)
     168
     169// FIXME: This probably belongs on Node.
     170// FIXME: This should take a const char*, but one caller passes nullAtom.
     171bool nodeHasRole(Node* node, const String& role)
    165172{
    166173    if (!node || !node->isElementNode())
    167174        return false;
    168    
     175
    169176    return equalIgnoringCase(static_cast<Element*>(node)->getAttribute(roleAttr), role);
    170177}
    171178
    172 AccessibilityObject* AXObjectCache::getOrCreate(RenderObject* renderer)
    173 {
    174     if (!renderer)
    175         return 0;
    176    
    177     AccessibilityObject* obj = get(renderer);
    178 
    179     if (!obj) {
    180         Node* node = renderer->node();
    181         RefPtr<AccessibilityObject> newObj = 0;
    182         if (renderer->isListBox())
    183             newObj = AccessibilityListBox::create(renderer);
    184         else if (renderer->isMenuList())
    185             newObj = AccessibilityMenuList::create(renderer);
    186 
    187         // If the node is aria role="list" or the aria role is empty and its a ul/ol/dl type (it shouldn't be a list if aria says otherwise).
    188         else if (node && ((nodeHasRole(node, "list") || nodeHasRole(node, "directory"))
    189                           || (nodeHasRole(node, nullAtom) && (node->hasTagName(ulTag) || node->hasTagName(olTag) || node->hasTagName(dlTag)))))
    190             newObj = AccessibilityList::create(renderer);
    191        
    192         // aria tables
    193         else if (nodeHasRole(node, "grid") || nodeHasRole(node, "treegrid"))
    194             newObj = AccessibilityARIAGrid::create(renderer);
    195         else if (nodeHasRole(node, "row"))
    196             newObj = AccessibilityARIAGridRow::create(renderer);
    197         else if (nodeHasRole(node, "gridcell") || nodeHasRole(node, "columnheader") || nodeHasRole(node, "rowheader"))
    198             newObj = AccessibilityARIAGridCell::create(renderer);
     179static PassRefPtr<AccessibilityObject> createFromRenderer(RenderObject* renderer)
     180{
     181    // FIXME: How could renderer->node() ever not be an Element?
     182    Node* node = renderer->node();
     183
     184    // If the node is aria role="list" or the aria role is empty and its a
     185    // ul/ol/dl type (it shouldn't be a list if aria says otherwise).
     186    if (node && ((nodeHasRole(node, "list") || nodeHasRole(node, "directory"))
     187                      || (nodeHasRole(node, nullAtom) && (node->hasTagName(ulTag) || node->hasTagName(olTag) || node->hasTagName(dlTag)))))
     188        return AccessibilityList::create(renderer);
     189
     190    // aria tables
     191    if (nodeHasRole(node, "grid") || nodeHasRole(node, "treegrid"))
     192        return AccessibilityARIAGrid::create(renderer);
     193    if (nodeHasRole(node, "row"))
     194        return AccessibilityARIAGridRow::create(renderer);
     195    if (nodeHasRole(node, "gridcell") || nodeHasRole(node, "columnheader") || nodeHasRole(node, "rowheader"))
     196        return AccessibilityARIAGridCell::create(renderer);
     197
     198#if ENABLE(VIDEO)
     199    // media controls
     200    if (node && node->isMediaControlElement())
     201        return AccessibilityMediaControl::create(renderer);
     202#endif
     203
     204    if (renderer->isBoxModelObject()) {
     205        RenderBoxModelObject* cssBox = toRenderBoxModelObject(renderer);
     206        if (cssBox->isListBox())
     207            return AccessibilityListBox::create(toRenderListBox(cssBox));
     208        if (cssBox->isMenuList())
     209            return AccessibilityMenuList::create(toRenderMenuList(cssBox));
    199210
    200211        // standard tables
    201         else if (renderer->isTable())
    202             newObj = AccessibilityTable::create(renderer);
    203         else if (renderer->isTableRow())
    204             newObj = AccessibilityTableRow::create(renderer);
    205         else if (renderer->isTableCell())
    206             newObj = AccessibilityTableCell::create(renderer);
    207 
    208 #if ENABLE(VIDEO)
    209         // media controls
    210         else if (renderer->node() && renderer->node()->isMediaControlElement())
    211             newObj = AccessibilityMediaControl::create(renderer);
    212 #endif
     212        if (cssBox->isTable())
     213            return AccessibilityTable::create(toRenderTable(cssBox));
     214        if (cssBox->isTableRow())
     215            return AccessibilityTableRow::create(toRenderTableRow(cssBox));
     216        if (cssBox->isTableCell())
     217            return AccessibilityTableCell::create(toRenderTableCell(cssBox));
    213218
    214219#if ENABLE(PROGRESS_TAG)
    215220        // progress bar
    216         else if (renderer->isProgress())
    217             newObj = AccessibilityProgressIndicator::create(toRenderProgress(renderer));
     221        if (cssBox->isProgress())
     222            return AccessibilityProgressIndicator::create(toRenderProgress(cssBox));
    218223#endif
    219224
    220225        // input type=range
    221         else if (renderer->isSlider())
    222             newObj = AccessibilitySlider::create(renderer);
    223 
    224         else
    225             newObj = AccessibilityRenderObject::create(renderer);
    226        
    227         obj = newObj.get();
    228        
    229         getAXID(obj);
    230        
    231         m_renderObjectMapping.set(renderer, obj->axObjectID());
    232         m_objects.set(obj->axObjectID(), obj);   
    233         attachWrapper(obj);
    234     }
    235    
    236     return obj;
     226        if (cssBox->isSlider())
     227            return AccessibilitySlider::create(toRenderSlider(cssBox));
     228    }
     229
     230    return AccessibilityRenderObject::create(renderer);
     231}
     232
     233AccessibilityObject* AXObjectCache::getOrCreate(RenderObject* renderer)
     234{
     235    if (!renderer)
     236        return 0;
     237
     238    if (AccessibilityObject* obj = get(renderer))
     239        return obj;
     240
     241    RefPtr<AccessibilityObject> newObj = createFromRenderer(renderer);
     242
     243    getAXID(newObj.get());
     244
     245    m_renderObjectMapping.set(renderer, newObj->axObjectID());
     246    m_objects.set(newObj->axObjectID(), newObj);
     247    attachWrapper(newObj.get());
     248    return newObj.get();
    237249}
    238250

  • trunk/WebCore/accessibility/AXObjectCache.h

    r64861 r64874  
    125125    void postNotification(AccessibilityObject*, Document*, AXNotification, bool postToElement, PostType = PostAsynchronously);
    126126
    127     bool nodeHasRole(Node*, const AtomicString& role);
    128 
    129127protected:
    130128    void postPlatformNotification(AccessibilityObject*, AXNotification);
    … …  
    147145};
    148146
     147bool nodeHasRole(Node*, const String& role);
     148
    149149#if !HAVE(ACCESSIBILITY)
    150150inline void AXObjectCache::handleActiveDescendantChanged(RenderObject*) { }

  • trunk/WebCore/accessibility/AccessibilityImageMapLink.cpp

    r63358 r64874  
    3434#include "Document.h"
    3535#include "HTMLNames.h"
    36 #include "IntRect.h"
    37 #include "RenderObject.h"
    38 
    39 using namespace std;
     36#include "RenderBoxModelObject.h"
    4037
    4138namespace WebCore {
    … …  
    4441
    4542AccessibilityImageMapLink::AccessibilityImageMapLink()
    46     : m_areaElement(0),
    47       m_mapElement(0)
     43    : m_areaElement(0)
     44    , m_mapElement(0)
    4845{
    4946}

  • trunk/WebCore/accessibility/AccessibilityMenuList.cpp

    r53512 r64874  
    3333namespace WebCore {
    3434
    35 AccessibilityMenuList::AccessibilityMenuList(RenderObject* renderer)
     35AccessibilityMenuList::AccessibilityMenuList(RenderMenuList* renderer)
    3636    : AccessibilityRenderObject(renderer)
    3737{
    38     ASSERT_ARG(renderer, renderer->isMenuList());
     38}
     39
     40RenderMenuList* AccessibilityMenuList::renderer() const
     41{
     42    return toRenderMenuList(AccessibilityRenderObject::renderer());
    3943}
    4044

  • trunk/WebCore/accessibility/AccessibilityMenuList.h

    r62978 r64874  
    3434class AccessibilityMenuListPopup;
    3535class HTMLOptionElement;
     36class RenderMenuList;
    3637
    3738class AccessibilityMenuList : public AccessibilityRenderObject {
    3839public:
    39     static PassRefPtr<AccessibilityMenuList> create(RenderObject* renderer) { return adoptRef(new AccessibilityMenuList(renderer)); }
     40    static PassRefPtr<AccessibilityMenuList> create(RenderMenuList* renderer) { return adoptRef(new AccessibilityMenuList(renderer)); }
    4041
    4142    virtual bool isCollapsed() const;
    4243    virtual bool press() const;
    4344
     45    RenderMenuList* renderer() const;
     46
    4447private:
    45     AccessibilityMenuList(RenderObject*);
     48    AccessibilityMenuList(RenderMenuList*);
    4649
    4750    virtual bool isMenuList() const { return true; }

  • trunk/WebCore/accessibility/AccessibilityMenuListPopup.cpp

    r53512 r64874  
    3232#include "HTMLNames.h"
    3333#include "HTMLSelectElement.h"
    34 #include "RenderObject.h"
     34#include "RenderMenuList.h"
    3535
    3636namespace WebCore {

  • trunk/WebCore/accessibility/AccessibilityObject.cpp

    r64721 r64874  
    417417static RenderListItem* renderListItemContainerForNode(Node* node)
    418418{
    419     for (Node* stringNode = node; stringNode; stringNode = stringNode->parent()) {
    420         RenderObject* renderObject = stringNode->renderer();
    421         if (!renderObject || !renderObject->isListItem())
    422             continue;
    423        
    424         return toRenderListItem(renderObject);
    425     }
    426    
     419    for (; node; node = node->parent()) {
     420        RenderBoxModelObject* renderer = node->renderBoxModelObject();
     421        if (renderer && renderer->isListItem())
     422            return toRenderListItem(renderer);
     423    }
    427424    return 0;
    428425}

  • trunk/WebCore/accessibility/AccessibilityRenderObject.cpp

    r64475 r64874  
    121121}
    122122
    123 static inline bool isInlineWithContinuation(RenderObject* renderer)
    124 {
     123RenderBoxModelObject* AccessibilityRenderObject::renderBoxModelObject() const
     124{
     125    if (!m_renderer || !m_renderer->isBoxModelObject())
     126        return 0;
     127    return toRenderBoxModelObject(m_renderer);
     128}
     129
     130static inline bool isInlineWithContinuation(RenderObject* object)
     131{
     132    if (!object->isBoxModelObject())
     133        return false;
     134
     135    RenderBoxModelObject* renderer = toRenderBoxModelObject(object);
    125136    if (!renderer->isRenderInline())
    126137        return false;
    … …  
    430441bool AccessibilityRenderObject::isNativeImage() const
    431442{
    432     return m_renderer->isImage();
     443    return m_renderer->isBoxModelObject() && toRenderBoxModelObject(m_renderer)->isImage();
    433444}   
    434445   
    … …  
    440451bool AccessibilityRenderObject::isAttachment() const
    441452{
    442     if (!m_renderer)
    443         return false;
    444    
     453    RenderBoxModelObject* renderer = renderBoxModelObject();
     454    if (!renderer)
     455        return false;
    445456    // Widgets are the replaced elements that we represent to AX as attachments
    446     bool isWidget = m_renderer && m_renderer->isWidget();
    447     ASSERT(!isWidget || (m_renderer->isReplaced() && !isImage()));
     457    bool isWidget = renderer->isWidget();
     458    ASSERT(!isWidget || (renderer->isReplaced() && !isImage()));
    448459    return isWidget && ariaRoleAttribute() == UnknownRole;
    449460}
    … …  
    604615        return false;
    605616   
    606     if (!m_renderer->isListBox())
     617    if (!m_renderer->isBoxModelObject() || !toRenderBoxModelObject(m_renderer)->isListBox())
    607618        return false;
    608619    return m_renderer->node() && static_cast<HTMLSelectElement*>(m_renderer->node())->multiple();
    … …  
    629640    }
    630641
    631     if (m_renderer->isTextField())
    632         return static_cast<HTMLInputElement*>(m_renderer->node())->readOnly();
    633     if (m_renderer->isTextArea())
    634         return static_cast<HTMLTextAreaElement*>(m_renderer->node())->readOnly();
    635    
     642    if (m_renderer->isBoxModelObject()) {
     643        RenderBoxModelObject* box = toRenderBoxModelObject(m_renderer);
     644        if (box->isTextField())
     645            return static_cast<HTMLInputElement*>(box->node())->readOnly();
     646        if (box->isTextArea())
     647            return static_cast<HTMLTextAreaElement*>(box->node())->readOnly();
     648    }
     649
    636650    return !m_renderer->node() || !m_renderer->node()->isContentEditable();
    637651}
    … …  
    700714bool AccessibilityRenderObject::isFieldset() const
    701715{
    702     if (!m_renderer)
    703         return false;
    704    
    705     return m_renderer->isFieldset();
     716    RenderBoxModelObject* renderer = renderBoxModelObject();
     717    if (!renderer)
     718        return false;
     719    return renderer->isFieldset();
    706720}
    707721 
    … …  
    790804            return static_cast<Element*>(node);
    791805    }
    792            
     806
    793807    if (isFileUploadButton())
    794808        return static_cast<Element*>(m_renderer->node());
    … …  
    800814        return static_cast<Element*>(m_renderer->node());
    801815   
    802     if (m_renderer->isMenuList())
     816    if (m_renderer->isBoxModelObject() && toRenderBoxModelObject(m_renderer)->isMenuList())
    803817        return static_cast<Element*>(m_renderer->node());
    804818
    … …  
    10501064    if (!m_renderer || isPasswordField())
    10511065        return String();
    1052    
     1066
     1067    RenderBoxModelObject* cssBox = renderBoxModelObject();
     1068
    10531069    if (ariaRoleAttribute() == StaticTextRole) {
    10541070        String staticText = text();
    … …  
    10611077        return textUnderElement();
    10621078   
    1063     if (m_renderer->isMenuList()) {
     1079    if (cssBox && cssBox->isMenuList()) {
    10641080        // RenderMenuList will go straight to the text() of its selected item.
    10651081        // This has to be overriden in the case where the selected item has an aria label
    … …  
    10831099        return toRenderListMarker(m_renderer)->text();
    10841100   
    1085     if (m_renderer->isRenderButton())
     1101    if (cssBox && cssBox->isRenderButton())
    10861102        return toRenderButton(m_renderer)->text();
    10871103
    … …  
    17021718    if (!isAllowedChildOfTree())
    17031719        return true;
    1704    
     1720
    17051721    // ignore popup menu items because AppKit does
    17061722    for (RenderObject* parent = m_renderer->parent(); parent; parent = parent->parent()) {
    1707         if (parent->isMenuList())
     1723        if (parent->isBoxModelObject() && toRenderBoxModelObject(parent)->isMenuList())
    17081724            return true;
    17091725    }
    1710    
     1726
    17111727    // find out if this element is inside of a label element.
    17121728    // if so, it may be ignored because it's the label for a checkbox or radio button
    … …  
    21832199void AccessibilityRenderObject::setValue(const String& string)
    21842200{
    2185     if (!m_renderer)
     2201    if (!m_renderer || !m_renderer->node() || !m_renderer->node()->isElementNode())
    21862202        return;
    2187    
     2203    Element* element = static_cast<Element*>(m_renderer->node());
     2204
     2205    if (roleValue() == SliderRole)
     2206        element->setAttribute(aria_valuenowAttr, string);
     2207
     2208    if (!m_renderer->isBoxModelObject())
     2209        return;
     2210    RenderBoxModelObject* renderer = toRenderBoxModelObject(m_renderer);
     2211
    21882212    // FIXME: Do we want to do anything here for ARIA textboxes?
    2189     if (m_renderer->isTextField()) {
    2190         HTMLInputElement* input = static_cast<HTMLInputElement*>(m_renderer->node());
    2191         input->setValue(string);
    2192     } else if (m_renderer->isTextArea()) {
    2193         HTMLTextAreaElement* textArea = static_cast<HTMLTextAreaElement*>(m_renderer->node());
    2194         textArea->setValue(string);
    2195     } else if (roleValue() == SliderRole) {
    2196         Node* element = m_renderer->node();
    2197         if (element && element->isElementNode())
    2198             static_cast<Element*>(element)->setAttribute(aria_valuenowAttr, string);
     2213    if (renderer->isTextField()) {
     2214        // FIXME: This is not safe!  Other elements could have a TextField renderer.
     2215        static_cast<HTMLInputElement*>(element)->setValue(string);
     2216    } else if (renderer->isTextArea()) {
     2217        // FIXME: This is not safe!  Other elements could have a TextArea renderer.
     2218        static_cast<HTMLTextAreaElement*>(element)->setValue(string);
    21992219    }
    22002220}
    … …  
    22562276Widget* AccessibilityRenderObject::widget() const
    22572277{
    2258     if (!m_renderer->isWidget())
     2278    if (!m_renderer->isBoxModelObject() || !toRenderBoxModelObject(m_renderer)->isWidget())
    22592279        return 0;
    22602280    return toRenderWidget(m_renderer)->widget();
    … …  
    25172537       
    25182538        pointResult = result.localPoint();
    2519        
     2539
    25202540        // done if hit something other than a widget
    2521         RenderObject* renderer = innerNode->renderer();
     2541        RenderBoxModelObject* renderer = innerNode->renderBoxModelObject();
    25222542        if (!renderer->isWidget())
    25232543            break;
    2524        
     2544
    25252545        // descend into widget (FRAME, IFRAME, OBJECT...)
    25262546        Widget* widget = toRenderWidget(renderer)->widget();
    … …  
    27072727    AccessibilityObject* result = obj->document()->axObjectCache()->getOrCreate(obj);
    27082728
    2709     if (obj->isListBox()) {
     2729    if (obj->isBoxModelObject() && toRenderBoxModelObject(obj)->isListBox()) {
    27102730        // Make sure the children are initialized so that hit testing finds the right element.
    27112731        AccessibilityListBox* listBox = static_cast<AccessibilityListBox*>(result);
    … …  
    27132733        return listBox->doAccessibilityHitTest(point);
    27142734    }
    2715        
     2735
    27162736    if (result->accessibilityIsIgnored()) {
    27172737        // If this element is the label of a control, a hit test should return the control.
    … …  
    28712891   
    28722892    // AX clients will listen for AXSelectedChildrenChanged on listboxes.
    2873     AXObjectCache* cache = axObjectCache();
    28742893    Node* node = renderer->node();
    2875     if (renderer->isListBox() || cache->nodeHasRole(node, "listbox"))
     2894    if (nodeHasRole(node, "listbox") || (renderer->isBoxModelObject() && toRenderBoxModelObject(renderer)->isListBox()))
    28762895        return true;
    2877    
     2896
    28782897    // Textboxes should send out notifications.
    2879     if (cache->nodeHasRole(node, "textbox"))
     2898    if (nodeHasRole(node, "textbox"))
    28802899        return true;
    28812900   
    … …  
    29512970    if (ariaRole != UnknownRole)
    29522971        return ariaRole;
    2953    
     2972
     2973    RenderBoxModelObject* cssBox = renderBoxModelObject();
     2974
    29542975    if (node && node->isLink()) {
    2955         if (m_renderer->isImage())
     2976        if (cssBox && cssBox->isImage())
    29562977            return ImageMapRole;
    29572978        return WebCoreLinkRole;
    29582979    }
    2959     if (m_renderer->isListItem())
     2980    if (cssBox && cssBox->isListItem())
    29602981        return ListItemRole;
    29612982    if (m_renderer->isListMarker())
    … …  
    29652986    if (m_renderer->isText())
    29662987        return StaticTextRole;
    2967     if (m_renderer->isImage()) {
     2988    if (cssBox && cssBox->isImage()) {
    29682989        if (node && node->hasTagName(inputTag))
    29692990            return ButtonRole;
    … …  
    29722993    if (node && node->hasTagName(canvasTag))
    29732994        return ImageRole;
    2974    
    2975     if (m_renderer->isRenderView())
     2995
     2996    if (cssBox && cssBox->isRenderView())
    29762997        return WebAreaRole;
    29772998   
    2978     if (m_renderer->isTextField())
     2999    if (cssBox && cssBox->isTextField())
    29793000        return TextFieldRole;
    29803001   
    2981     if (m_renderer->isTextArea())
     3002    if (cssBox && cssBox->isTextArea())
    29823003        return TextAreaRole;
    2983    
     3004
    29843005    if (node && node->hasTagName(inputTag)) {
    29853006        HTMLInputElement* input = static_cast<HTMLInputElement*>(node);
    … …  
    29983019        return ButtonRole;
    29993020   
    3000     if (m_renderer->isMenuList())
     3021    if (cssBox && cssBox->isMenuList())
    30013022        return PopUpButtonRole;
    30023023   
    … …  
    32883309   
    32893310    // for a RenderImage, add the <area> elements as individual accessibility objects
    3290     if (m_renderer->isRenderImage()) {
    3291         HTMLMapElement* map = toRenderImage(m_renderer)->imageMap();
     3311    RenderBoxModelObject* cssBox = renderBoxModelObject();
     3312    if (cssBox && cssBox->isRenderImage()) {
     3313        HTMLMapElement* map = toRenderImage(cssBox)->imageMap();
    32923314        if (map) {
    32933315            for (Node* current = map->firstChild(); current; current = current->traverseNextNode(map)) {
    … …  
    36063628        return EditableTextRole;
    36073629
    3608     if (renderer->isListItem())
     3630    if (renderer->isBoxModelObject() && toRenderBoxModelObject(renderer)->isListItem())
    36093631        return ListItemRole;
    36103632

  • trunk/WebCore/accessibility/AccessibilityRenderObject.h

    r64861 r64874  
     1
    12/*
    23 * Copyright (C) 2008 Apple Inc. All rights reserved.
    … …  
    3132
    3233#include "AccessibilityObject.h"
    33 #include "RenderObject.h"
     34#include <wtf/Forward.h>
    3435
    3536namespace WebCore {
    … …  
    166167    void setRenderer(RenderObject* renderer) { m_renderer = renderer; }
    167168    RenderObject* renderer() const { return m_renderer; }
     169    RenderBoxModelObject* renderBoxModelObject() const;
    168170    virtual Node* node() const;
    169171

  • trunk/WebCore/accessibility/AccessibilityTable.cpp

    r63994 r64874  
    4444#include "RenderTableSection.h"
    4545
    46 using namespace std;
    47 
    4846namespace WebCore {
    4947
    … …  
    7674    // is to only show "data" tables
    7775   
    78     if (!m_renderer || !m_renderer->isTable())
     76    if (!renderer())
    7977        return false;
    8078   
    … …  
    197195            if (row < 5 && row == alternatingRowColorCount) {
    198196                RenderObject* renderRow = cell->parent();
    199                 if (!renderRow || !renderRow->isTableRow())
     197                if (!renderRow || !renderRow->isBoxModelObject() || !toRenderBoxModelObject(renderRow)->isTableRow())
    200198                    continue;
    201199                RenderStyle* rowRenderStyle = renderRow->style();

  • trunk/WebCore/accessibility/AccessibilityTable.h

    r64861 r64874  
    5151    static PassRefPtr<AccessibilityTable> create(RenderObject*);
    5252    virtual ~AccessibilityTable();
    53    
     53
    5454    virtual bool isDataTable() const;
    5555    virtual AccessibilityRole roleValue() const;
    … …  
    7979    // an object that contains, as children, all the objects that act as headers
    8080    AccessibilityObject* headerContainer();
    81    
    82 protected:   
     81
     82protected:
    8383    AccessibilityChildrenVector m_rows;
    8484    AccessibilityChildrenVector m_columns;
    85    
     85
    8686    AccessibilityTableHeaderContainer* m_headerContainer;
    8787    mutable bool m_isAccessibilityTable;
    88    
     88
    8989    bool isTableExposableThroughAccessibility();
    9090};
    91    
     91
    9292} // namespace WebCore
    9393
Note: See TracChangeset for help on using the changeset viewer.