⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 202961 in webkit


Ignore:
Timestamp:
Jul 7, 2016, 10:51:20 PM (10 years ago)
Author:
fred.wang@free.fr
Message:

Move MathML-specific code into a separate accessibility class
​https://bugs.webkit.org/show_bug.cgi?id=159213

Patch by Frederic Wang <​fwang@igalia.com> on 2016-07-07
Reviewed by Chris Fleizach.

Currently, MathML accessibility is completely handled in the generic AccessibilityRenderObject
and it's sometimes messy and unconvenient. Hence we move most of the MathML-specific code
into a separate AccessibilityMathMLElement class to facilitate future work and maintenance.

No new tests, already covered by existing tests.

  • CMakeLists.txt: Add new AccessibilityMathMLElement module.
  • WebCore.xcodeproj/project.pbxproj: Ditto.
  • accessibility/AccessibilityAllInOne.cpp: Ditto.
  • accessibility/AXObjectCache.cpp: Add MathML headers and create AccessibilityMathMLElement.

(WebCore::createFromRenderer): Create AccessibilityMathMLElement for MathML elements and
anonymous operators created by the mfenced element.

  • accessibility/AccessibilityMathMLElement.cpp: Added. This class handles all the MathML

elements as well as the anonymous operators created by the mfenced element. A boolean is
passed to the constructor to indicate whether we are in the latter case.
(WebCore::AccessibilityMathMLElement::AccessibilityMathMLElement):
(WebCore::AccessibilityMathMLElement::~AccessibilityMathMLElement):
(WebCore::AccessibilityMathMLElement::create):
(WebCore::AccessibilityMathMLElement::determineAccessibilityRole): Move handling of specific
MathElementRole and DocumentMathRole here.
(WebCore::AccessibilityMathMLElement::textUnderElement): Move retrieval of text from the
anonymous operators here.
(WebCore::AccessibilityMathMLElement::stringValue): Ditto.
(WebCore::AccessibilityMathMLElement::isIgnoredElementWithinMathTree): Move the determination
of ignored math elements here.
(WebCore::AccessibilityMathMLElement::isMathFraction): Moved from AccessibilityRenderObject.
(WebCore::AccessibilityMathMLElement::isMathFenced): Ditto.
(WebCore::AccessibilityMathMLElement::isMathSubscriptSuperscript): Ditto.
(WebCore::AccessibilityMathMLElement::isMathRow): Ditto.
(WebCore::AccessibilityMathMLElement::isMathUnderOver): Ditto.
(WebCore::AccessibilityMathMLElement::isMathSquareRoot): Ditto.
(WebCore::AccessibilityMathMLElement::isMathToken): Ditto.
(WebCore::AccessibilityMathMLElement::isMathRoot): Ditto.
(WebCore::AccessibilityMathMLElement::isMathOperator): Ditto.
(WebCore::AccessibilityMathMLElement::isAnonymousMathOperator): Move the determination of
anonymous operators here. We now just return the boolean passed at creation time.
(WebCore::AccessibilityMathMLElement::isMathFenceOperator): Moved from
AccessibilityRenderObject.
(WebCore::AccessibilityMathMLElement::isMathSeparatorOperator): Ditto.
(WebCore::AccessibilityMathMLElement::isMathText): Ditto.
(WebCore::AccessibilityMathMLElement::isMathNumber): Ditto.
(WebCore::AccessibilityMathMLElement::isMathIdentifier): Ditto.
(WebCore::AccessibilityMathMLElement::isMathMultiscript): Ditto.
(WebCore::AccessibilityMathMLElement::isMathTable): Ditto.
(WebCore::AccessibilityMathMLElement::isMathTableRow): Ditto.
(WebCore::AccessibilityMathMLElement::isMathTableCell): Ditto.
(WebCore::AccessibilityMathMLElement::isMathScriptObject): Ditto.
(WebCore::AccessibilityMathMLElement::isMathMultiscriptObject): Ditto.
(WebCore::AccessibilityMathMLElement::mathRadicandObject): Ditto.
(WebCore::AccessibilityMathMLElement::mathRootIndexObject): Ditto.
(WebCore::AccessibilityMathMLElement::mathNumeratorObject): Ditto.
(WebCore::AccessibilityMathMLElement::mathDenominatorObject): Ditto.
(WebCore::AccessibilityMathMLElement::mathUnderObject): Ditto.
(WebCore::AccessibilityMathMLElement::mathOverObject): Ditto.
(WebCore::AccessibilityMathMLElement::mathBaseObject): Ditto.
(WebCore::AccessibilityMathMLElement::mathSubscriptObject): Ditto.
(WebCore::AccessibilityMathMLElement::mathSuperscriptObject): Ditto.
(WebCore::AccessibilityMathMLElement::mathFencedOpenString): Ditto.
(WebCore::AccessibilityMathMLElement::mathFencedCloseString): Ditto.
(WebCore::AccessibilityMathMLElement::mathPrescripts): Ditto.
(WebCore::AccessibilityMathMLElement::mathPostscripts): Ditto.
(WebCore::AccessibilityMathMLElement::mathLineThickness): Ditto.

  • accessibility/AccessibilityMathMLElement.h: Added.
  • accessibility/AccessibilityRenderObject.cpp:

(WebCore::AccessibilityRenderObject::isIgnoredElementWithinMathTree): The cases of
AccessibilityMathMLElement objects are now handled in the derived class. We remove the case
of text node since the MathML code no longer creates anonymous text nodes after r202420.
Anonymous block inserted into RenderMathMLBlocks to honor CSS rules are not AccessibilityMathMLElements
and it does not seem safe to modify AXObjectCache::createFromRenderer to force that. Hence
we still need to be handle them here.
(WebCore::AccessibilityRenderObject::textUnderElement): This code is moved into AccessibilityMathMLElement.
(WebCore::AccessibilityRenderObject::stringValue): Ditto.
(WebCore::AccessibilityRenderObject::determineAccessibilityRole): Ditto.
(WebCore::AccessibilityRenderObject::isMathElement): Deleted.
(WebCore::AccessibilityRenderObject::isMathFraction): Deleted.
(WebCore::AccessibilityRenderObject::isMathFenced): Deleted.
(WebCore::AccessibilityRenderObject::isMathSubscriptSuperscript): Deleted.
(WebCore::AccessibilityRenderObject::isMathRow): Deleted.
(WebCore::AccessibilityRenderObject::isMathUnderOver): Deleted.
(WebCore::AccessibilityRenderObject::isMathSquareRoot): Deleted.
(WebCore::AccessibilityRenderObject::isMathToken): Deleted.
(WebCore::AccessibilityRenderObject::isMathRoot): Deleted.
(WebCore::AccessibilityRenderObject::isMathOperator): Deleted.
(WebCore::AccessibilityRenderObject::isAnonymousMathOperator): Deleted.
(WebCore::AccessibilityRenderObject::isMathFenceOperator): Deleted.
(WebCore::AccessibilityRenderObject::isMathSeparatorOperator): Deleted.
(WebCore::AccessibilityRenderObject::isMathText): Deleted.
(WebCore::AccessibilityRenderObject::isMathNumber): Deleted.
(WebCore::AccessibilityRenderObject::isMathIdentifier): Deleted.
(WebCore::AccessibilityRenderObject::isMathMultiscript): Deleted.
(WebCore::AccessibilityRenderObject::isMathTable): Deleted.
(WebCore::AccessibilityRenderObject::isMathTableRow): Deleted.
(WebCore::AccessibilityRenderObject::isMathTableCell): Deleted.
(WebCore::AccessibilityRenderObject::isMathScriptObject): Deleted.
(WebCore::AccessibilityRenderObject::isMathMultiscriptObject): Deleted.
(WebCore::AccessibilityRenderObject::mathRadicandObject): Deleted.
(WebCore::AccessibilityRenderObject::mathRootIndexObject): Deleted.
(WebCore::AccessibilityRenderObject::mathNumeratorObject): Deleted.
(WebCore::AccessibilityRenderObject::mathDenominatorObject): Deleted.
(WebCore::AccessibilityRenderObject::mathUnderObject): Deleted.
(WebCore::AccessibilityRenderObject::mathOverObject): Deleted.
(WebCore::AccessibilityRenderObject::mathBaseObject): Deleted.
(WebCore::AccessibilityRenderObject::mathSubscriptObject): Deleted.
(WebCore::AccessibilityRenderObject::mathSuperscriptObject): Deleted.
(WebCore::AccessibilityRenderObject::mathFencedOpenString): Deleted.
(WebCore::AccessibilityRenderObject::mathFencedCloseString): Deleted.
(WebCore::AccessibilityRenderObject::mathPrescripts): Deleted.
(WebCore::AccessibilityRenderObject::mathPostscripts): Deleted.
(WebCore::AccessibilityRenderObject::mathLineThickness): Deleted.

  • accessibility/AccessibilityRenderObject.h: Remove declarations of functions that are now

overridden in AccessibilityMathMLElement. Make isIgnoredElementWithinMathTree virtual so that
it can be reimplemented in AccessibilityMathMLElement.

Location:
trunk/Source/WebCore
Files:
2 added
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/CMakeLists.txt

    r202960 r202961  
    10541054    accessibility/AccessibilityListBox.cpp
    10551055    accessibility/AccessibilityListBoxOption.cpp
     1056    accessibility/AccessibilityMathMLElement.cpp
    10561057    accessibility/AccessibilityMediaControls.cpp
    10571058    accessibility/AccessibilityMenuList.cpp

  • trunk/Source/WebCore/ChangeLog

    r202960 r202961  
     12016-07-07  Frederic Wang  <fwang@igalia.com>
     2
     3        Move MathML-specific code into a separate accessibility class
     4        https://bugs.webkit.org/show_bug.cgi?id=159213
     5
     6        Reviewed by Chris Fleizach.
     7
     8        Currently, MathML accessibility is completely handled in the generic AccessibilityRenderObject
     9        and it's sometimes messy and unconvenient. Hence we move most of the MathML-specific code
     10        into a separate AccessibilityMathMLElement class to facilitate future work and maintenance.
     11
     12        No new tests, already covered by existing tests.
     13
     14        * CMakeLists.txt: Add new AccessibilityMathMLElement module.
     15        * WebCore.xcodeproj/project.pbxproj: Ditto.
     16        * accessibility/AccessibilityAllInOne.cpp: Ditto.
     17        * accessibility/AXObjectCache.cpp: Add MathML headers and create AccessibilityMathMLElement.
     18        (WebCore::createFromRenderer): Create AccessibilityMathMLElement for MathML elements and
     19        anonymous operators created by the mfenced element.
     20        * accessibility/AccessibilityMathMLElement.cpp: Added. This class handles all the MathML
     21        elements as well as the anonymous operators created by the mfenced element. A boolean is
     22        passed to the constructor to indicate whether we are in the latter case.
     23        (WebCore::AccessibilityMathMLElement::AccessibilityMathMLElement):
     24        (WebCore::AccessibilityMathMLElement::~AccessibilityMathMLElement):
     25        (WebCore::AccessibilityMathMLElement::create):
     26        (WebCore::AccessibilityMathMLElement::determineAccessibilityRole): Move handling of specific
     27        MathElementRole and DocumentMathRole here.
     28        (WebCore::AccessibilityMathMLElement::textUnderElement): Move retrieval of text from the
     29        anonymous operators here.
     30        (WebCore::AccessibilityMathMLElement::stringValue): Ditto.
     31        (WebCore::AccessibilityMathMLElement::isIgnoredElementWithinMathTree): Move the determination
     32        of ignored math elements here.
     33        (WebCore::AccessibilityMathMLElement::isMathFraction): Moved from AccessibilityRenderObject.
     34        (WebCore::AccessibilityMathMLElement::isMathFenced): Ditto.
     35        (WebCore::AccessibilityMathMLElement::isMathSubscriptSuperscript): Ditto.
     36        (WebCore::AccessibilityMathMLElement::isMathRow): Ditto.
     37        (WebCore::AccessibilityMathMLElement::isMathUnderOver): Ditto.
     38        (WebCore::AccessibilityMathMLElement::isMathSquareRoot): Ditto.
     39        (WebCore::AccessibilityMathMLElement::isMathToken): Ditto.
     40        (WebCore::AccessibilityMathMLElement::isMathRoot): Ditto.
     41        (WebCore::AccessibilityMathMLElement::isMathOperator): Ditto.
     42        (WebCore::AccessibilityMathMLElement::isAnonymousMathOperator): Move the determination of
     43        anonymous operators here. We now just return the boolean passed at creation time.
     44        (WebCore::AccessibilityMathMLElement::isMathFenceOperator): Moved from
     45        AccessibilityRenderObject.
     46        (WebCore::AccessibilityMathMLElement::isMathSeparatorOperator): Ditto.
     47        (WebCore::AccessibilityMathMLElement::isMathText): Ditto.
     48        (WebCore::AccessibilityMathMLElement::isMathNumber): Ditto.
     49        (WebCore::AccessibilityMathMLElement::isMathIdentifier): Ditto.
     50        (WebCore::AccessibilityMathMLElement::isMathMultiscript): Ditto.
     51        (WebCore::AccessibilityMathMLElement::isMathTable): Ditto.
     52        (WebCore::AccessibilityMathMLElement::isMathTableRow): Ditto.
     53        (WebCore::AccessibilityMathMLElement::isMathTableCell): Ditto.
     54        (WebCore::AccessibilityMathMLElement::isMathScriptObject): Ditto.
     55        (WebCore::AccessibilityMathMLElement::isMathMultiscriptObject): Ditto.
     56        (WebCore::AccessibilityMathMLElement::mathRadicandObject): Ditto.
     57        (WebCore::AccessibilityMathMLElement::mathRootIndexObject): Ditto.
     58        (WebCore::AccessibilityMathMLElement::mathNumeratorObject): Ditto.
     59        (WebCore::AccessibilityMathMLElement::mathDenominatorObject): Ditto.
     60        (WebCore::AccessibilityMathMLElement::mathUnderObject): Ditto.
     61        (WebCore::AccessibilityMathMLElement::mathOverObject): Ditto.
     62        (WebCore::AccessibilityMathMLElement::mathBaseObject): Ditto.
     63        (WebCore::AccessibilityMathMLElement::mathSubscriptObject): Ditto.
     64        (WebCore::AccessibilityMathMLElement::mathSuperscriptObject): Ditto.
     65        (WebCore::AccessibilityMathMLElement::mathFencedOpenString): Ditto.
     66        (WebCore::AccessibilityMathMLElement::mathFencedCloseString): Ditto.
     67        (WebCore::AccessibilityMathMLElement::mathPrescripts): Ditto.
     68        (WebCore::AccessibilityMathMLElement::mathPostscripts): Ditto.
     69        (WebCore::AccessibilityMathMLElement::mathLineThickness): Ditto.
     70        * accessibility/AccessibilityMathMLElement.h: Added.
     71        * accessibility/AccessibilityRenderObject.cpp:
     72        (WebCore::AccessibilityRenderObject::isIgnoredElementWithinMathTree): The cases of
     73        AccessibilityMathMLElement objects are now handled in the derived class. We remove the case
     74        of text node since the MathML code no longer creates anonymous text nodes after r202420.
     75        Anonymous block inserted into RenderMathMLBlocks to honor CSS rules are not AccessibilityMathMLElements
     76        and it does not seem safe to modify AXObjectCache::createFromRenderer to force that. Hence
     77        we still need to be handle them here.
     78        (WebCore::AccessibilityRenderObject::textUnderElement): This code is moved into AccessibilityMathMLElement.
     79        (WebCore::AccessibilityRenderObject::stringValue): Ditto.
     80        (WebCore::AccessibilityRenderObject::determineAccessibilityRole): Ditto.
     81        (WebCore::AccessibilityRenderObject::isMathElement): Deleted.
     82        (WebCore::AccessibilityRenderObject::isMathFraction): Deleted.
     83        (WebCore::AccessibilityRenderObject::isMathFenced): Deleted.
     84        (WebCore::AccessibilityRenderObject::isMathSubscriptSuperscript): Deleted.
     85        (WebCore::AccessibilityRenderObject::isMathRow): Deleted.
     86        (WebCore::AccessibilityRenderObject::isMathUnderOver): Deleted.
     87        (WebCore::AccessibilityRenderObject::isMathSquareRoot): Deleted.
     88        (WebCore::AccessibilityRenderObject::isMathToken): Deleted.
     89        (WebCore::AccessibilityRenderObject::isMathRoot): Deleted.
     90        (WebCore::AccessibilityRenderObject::isMathOperator): Deleted.
     91        (WebCore::AccessibilityRenderObject::isAnonymousMathOperator): Deleted.
     92        (WebCore::AccessibilityRenderObject::isMathFenceOperator): Deleted.
     93        (WebCore::AccessibilityRenderObject::isMathSeparatorOperator): Deleted.
     94        (WebCore::AccessibilityRenderObject::isMathText): Deleted.
     95        (WebCore::AccessibilityRenderObject::isMathNumber): Deleted.
     96        (WebCore::AccessibilityRenderObject::isMathIdentifier): Deleted.
     97        (WebCore::AccessibilityRenderObject::isMathMultiscript): Deleted.
     98        (WebCore::AccessibilityRenderObject::isMathTable): Deleted.
     99        (WebCore::AccessibilityRenderObject::isMathTableRow): Deleted.
     100        (WebCore::AccessibilityRenderObject::isMathTableCell): Deleted.
     101        (WebCore::AccessibilityRenderObject::isMathScriptObject): Deleted.
     102        (WebCore::AccessibilityRenderObject::isMathMultiscriptObject): Deleted.
     103        (WebCore::AccessibilityRenderObject::mathRadicandObject): Deleted.
     104        (WebCore::AccessibilityRenderObject::mathRootIndexObject): Deleted.
     105        (WebCore::AccessibilityRenderObject::mathNumeratorObject): Deleted.
     106        (WebCore::AccessibilityRenderObject::mathDenominatorObject): Deleted.
     107        (WebCore::AccessibilityRenderObject::mathUnderObject): Deleted.
     108        (WebCore::AccessibilityRenderObject::mathOverObject): Deleted.
     109        (WebCore::AccessibilityRenderObject::mathBaseObject): Deleted.
     110        (WebCore::AccessibilityRenderObject::mathSubscriptObject): Deleted.
     111        (WebCore::AccessibilityRenderObject::mathSuperscriptObject): Deleted.
     112        (WebCore::AccessibilityRenderObject::mathFencedOpenString): Deleted.
     113        (WebCore::AccessibilityRenderObject::mathFencedCloseString): Deleted.
     114        (WebCore::AccessibilityRenderObject::mathPrescripts): Deleted.
     115        (WebCore::AccessibilityRenderObject::mathPostscripts): Deleted.
     116        (WebCore::AccessibilityRenderObject::mathLineThickness): Deleted.
     117        * accessibility/AccessibilityRenderObject.h: Remove declarations of functions that are now
     118        overridden in AccessibilityMathMLElement. Make isIgnoredElementWithinMathTree virtual so that
     119        it can be reimplemented in AccessibilityMathMLElement.
     120
    11212016-07-07  Frederic Wang  <fwang@igalia.com>
    2122

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r202960 r202961  
    295295                07AC47021952102100EE9723 /* ISOVTTCue.h in Headers */ = {isa = PBXBuildFile; fileRef = 07AC47001952102100EE9723 /* ISOVTTCue.h */; };
    296296                07B0113F1032242200FBDC33 /* AccessibilityMediaControls.h in Headers */ = {isa = PBXBuildFile; fileRef = 07B0113E1032242200FBDC33 /* AccessibilityMediaControls.h */; };
     297                07B0ABCF1032242200FBDC33 /* AccessibilityMathMLElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 07B0ABCE1032242200FBDC33 /* AccessibilityMathMLElement.h */; };
    297298                07B442D6166C70B000556CAD /* InbandTextTrackPrivateAVF.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 07B442D4166C70B000556CAD /* InbandTextTrackPrivateAVF.cpp */; };
    298299                07B442D7166C70B000556CAD /* InbandTextTrackPrivateAVF.h in Headers */ = {isa = PBXBuildFile; fileRef = 07B442D5166C70B000556CAD /* InbandTextTrackPrivateAVF.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    15221523                37F57ABF1A50728100876F98 /* AccessibilityListBoxOption.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2981CAA3131822EC00D12F2A /* AccessibilityListBoxOption.cpp */; };
    15231524                37F57AC01A50728400876F98 /* AccessibilityMediaControls.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2981CAA4131822EC00D12F2A /* AccessibilityMediaControls.cpp */; };
     1525                37F57ABC1A50728400876F98 /* AccessibilityMathMLElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2981ABC4131822EC00D12F2A /* AccessibilityMathMLElement.cpp */; };
    15241526                37F57AC11A50728700876F98 /* AccessibilityNodeObject.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2985709215CC532D006355CD /* AccessibilityNodeObject.cpp */; };
    15251527                37F57AC21A50728B00876F98 /* AccessibilityObject.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2981CAA5131822EC00D12F2A /* AccessibilityObject.cpp */; };
    … …  
    77617763                07AC47001952102100EE9723 /* ISOVTTCue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ISOVTTCue.h; sourceTree = "<group>"; };
    77627764                07B0113E1032242200FBDC33 /* AccessibilityMediaControls.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AccessibilityMediaControls.h; sourceTree = "<group>"; };
     7765                07B0ABCE1032242200FBDC33 /* AccessibilityMathMLElement.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AccessibilityMathMLElement.h; sourceTree = "<group>"; };
    77637766                07B442D4166C70B000556CAD /* InbandTextTrackPrivateAVF.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = InbandTextTrackPrivateAVF.cpp; sourceTree = "<group>"; };
    77647767                07B442D5166C70B000556CAD /* InbandTextTrackPrivateAVF.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InbandTextTrackPrivateAVF.h; sourceTree = "<group>"; };
    … …  
    86968699                2981CAA3131822EC00D12F2A /* AccessibilityListBoxOption.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = AccessibilityListBoxOption.cpp; sourceTree = "<group>"; };
    86978700                2981CAA4131822EC00D12F2A /* AccessibilityMediaControls.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = AccessibilityMediaControls.cpp; sourceTree = "<group>"; };
     8701                2981ABC4131822EC00D12F2A /* AccessibilityMathMLElement.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = AccessibilityMathMLElement.cpp; sourceTree = "<group>"; };
    86988702                2981CAA5131822EC00D12F2A /* AccessibilityObject.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; lineEnding = 0; path = AccessibilityObject.cpp; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.cpp; };
    86998703                2981CAA6131822EC00D12F2A /* AccessibilityRenderObject.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = AccessibilityRenderObject.cpp; sourceTree = "<group>"; };
    … …  
    1671916723                                2981CAA4131822EC00D12F2A /* AccessibilityMediaControls.cpp */,
    1672016724                                07B0113E1032242200FBDC33 /* AccessibilityMediaControls.h */,
     16725                                2981ABC4131822EC00D12F2A /* AccessibilityMathMLElement.cpp */,
     16726                                07B0ABCE1032242200FBDC33 /* AccessibilityMathMLElement.h */,
    1672116727                                76CDD2EC1103DA6600680521 /* AccessibilityMenuList.cpp */,
    1672216728                                76CDD2ED1103DA6600680521 /* AccessibilityMenuList.h */,
    … …  
    2529025296                                29A812420FBB9C1D00510293 /* AccessibilityListBoxOption.h in Headers */,
    2529125297                                07B0113F1032242200FBDC33 /* AccessibilityMediaControls.h in Headers */,
     25298                                07B0ABCF1032242200FBDC33 /* AccessibilityMathMLElement.h in Headers */,
    2529225299                                76CDD2F31103DA6600680521 /* AccessibilityMenuList.h in Headers */,
    2529325300                                76CDD2F71103DA6600680521 /* AccessibilityMenuListOption.h in Headers */,
    … …  
    2930829315                                37F57ABF1A50728100876F98 /* AccessibilityListBoxOption.cpp in Sources */,
    2930929316                                37F57AC01A50728400876F98 /* AccessibilityMediaControls.cpp in Sources */,
     29317                                37F57ABC1A50728400876F98 /* AccessibilityMathMLElement.cpp in Sources */,
    2931029318                                76CDD2F21103DA6600680521 /* AccessibilityMenuList.cpp in Sources */,
    2931129319                                76CDD2F61103DA6600680521 /* AccessibilityMenuListOption.cpp in Sources */,

  • trunk/Source/WebCore/accessibility/AXObjectCache.cpp

    r202762 r202961  
    4242#include "AccessibilityListBox.h"
    4343#include "AccessibilityListBoxOption.h"
     44#include "AccessibilityMathMLElement.h"
    4445#include "AccessibilityMediaControls.h"
    4546#include "AccessibilityMenuList.h"
    … …  
    7475#include "HTMLNames.h"
    7576#include "InlineElementBox.h"
     77#include "MathMLElement.h"
    7678#include "Page.h"
    7779#include "RenderAttachment.h"
    7880#include "RenderLineBreak.h"
    7981#include "RenderListBox.h"
     82#include "RenderMathMLOperator.h"
    8083#include "RenderMenuList.h"
    8184#include "RenderMeter.h"
    … …  
    444447    if (is<SVGElement>(node))
    445448        return AccessibilitySVGElement::create(renderer);
     449
     450#if ENABLE(MATHML)
     451    // The mfenced element creates anonymous RenderMathMLOperators which should be treated
     452    // as MathML elements and assigned the MathElementRole so that platform logic regarding
     453    // inclusion and role mapping is not bypassed.
     454    bool isAnonymousOperator = renderer->isAnonymous() && is<RenderMathMLOperator>(*renderer);
     455    if (isAnonymousOperator || is<MathMLElement>(node))
     456        return AccessibilityMathMLElement::create(renderer, isAnonymousOperator);
     457#endif
    446458
    447459    if (is<RenderBoxModelObject>(*renderer)) {

  • trunk/Source/WebCore/accessibility/AccessibilityAllInOne.cpp

    r202063 r202961  
    3636#include "AccessibilityListBox.cpp"
    3737#include "AccessibilityListBoxOption.cpp"
     38#include "AccessibilityMathMLElement.cpp"
    3839#include "AccessibilityMediaControls.cpp"
    3940#include "AccessibilityMenuList.cpp"

  • trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp

    r202562 r202961  
    6767#include "Image.h"
    6868#include "LocalizedStrings.h"
    69 #include "MathMLNames.h"
    7069#include "NodeList.h"
    7170#include "Page.h"
    … …  
    8483#include "RenderListMarker.h"
    8584#include "RenderMathMLBlock.h"
    86 #include "RenderMathMLFraction.h"
    87 #include "RenderMathMLMath.h"
    88 #include "RenderMathMLOperator.h"
    89 #include "RenderMathMLRoot.h"
    9085#include "RenderMenuList.h"
    9186#include "RenderSVGRoot.h"
    … …  
    632627    bool isRenderText = is<RenderText>(*m_renderer);
    633628
    634 #if ENABLE(MATHML)
    635     if (isAnonymousMathOperator()) {
    636         UChar operatorChar = downcast<RenderMathMLOperator>(*m_renderer).textContent();
    637         return operatorChar ? String(&operatorChar, 1) : String();
    638     }
    639 #endif
    640 
    641629    if (shouldGetTextFromNode(mode))
    642630        return AccessibilityNodeObject::textUnderElement(mode);
    … …  
    762750        return textUnderElement();
    763751
    764     if (isAnonymousMathOperator())
    765         return textUnderElement();
    766    
    767752    if (is<RenderMenuList>(cssBox)) {
    768753        // RenderMenuList will go straight to the text() of its selected item.
    … …  
    26302615        return is<RenderInline>(*m_renderer) ? InlineRole : GroupRole;
    26312616   
    2632 #if ENABLE(MATHML)
    2633     if (node && node->hasTagName(MathMLNames::mathTag))
    2634         return DocumentMathRole;
    2635 #endif
    2636     // It's not clear which role a platform should choose for a math element.
    2637     // Declaring a math element role should give flexibility to platforms to choose.
    2638     if (isMathElement())
    2639         return MathElementRole;
    2640    
    26412617    if (node && node->hasTagName(ddTag))
    26422618        return DescriptionListDetailRole;
    … …  
    36073583
    36083584#if ENABLE(MATHML)
    3609 bool AccessibilityRenderObject::isMathElement() const
    3610 {
    3611     if (!m_renderer)
    3612         return false;
    3613    
    3614     // The mfenced element creates anonymous RenderMathMLOperators which should be treated
    3615     // as MathML elements and assigned the MathElementRole so that platform logic regarding
    3616     // inclusion and role mapping is not bypassed.
    3617     if (isAnonymousMathOperator())
    3618         return true;
    3619 
    3620     return is<MathMLElement>(node());
    3621 }
    3622 
    3623 bool AccessibilityRenderObject::isMathFraction() const
    3624 {
    3625     return m_renderer && m_renderer->isRenderMathMLFraction();
    3626 }
    3627 
    3628 bool AccessibilityRenderObject::isMathFenced() const
    3629 {
    3630     return m_renderer && m_renderer->isRenderMathMLFenced();
    3631 }
    3632 
    3633 bool AccessibilityRenderObject::isMathSubscriptSuperscript() const
    3634 {
    3635     return m_renderer && m_renderer->isRenderMathMLScripts() && !isMathMultiscript();
    3636 }
    3637 
    3638 bool AccessibilityRenderObject::isMathRow() const
    3639 {
    3640     return m_renderer && m_renderer->isRenderMathMLRow() && !isMathRoot();
    3641 }
    3642 
    3643 bool AccessibilityRenderObject::isMathUnderOver() const
    3644 {
    3645     return m_renderer && m_renderer->isRenderMathMLUnderOver();
    3646 }
    3647 
    3648 bool AccessibilityRenderObject::isMathSquareRoot() const
    3649 {
    3650     return m_renderer && m_renderer->isRenderMathMLSquareRoot();
    3651 }
    3652    
    3653 bool AccessibilityRenderObject::isMathToken() const
    3654 {
    3655     return m_renderer && m_renderer->isRenderMathMLToken();
    3656 }
    3657 
    3658 bool AccessibilityRenderObject::isMathRoot() const
    3659 {
    3660     return m_renderer && m_renderer->isRenderMathMLRoot();
    3661 }
    3662 
    3663 bool AccessibilityRenderObject::isMathOperator() const
    3664 {
    3665     if (!m_renderer || !m_renderer->isRenderMathMLOperator())
    3666         return false;
    3667 
    3668     return true;
    3669 }
    3670 
    3671 bool AccessibilityRenderObject::isAnonymousMathOperator() const
    3672 {
    3673     return is<RenderMathMLOperator>(m_renderer) && m_renderer->isAnonymous();
    3674 }
    3675 
    3676 bool AccessibilityRenderObject::isMathFenceOperator() const
    3677 {
    3678     if (!is<RenderMathMLOperator>(m_renderer))
    3679         return false;
    3680 
    3681     return downcast<RenderMathMLOperator>(*m_renderer).hasOperatorFlag(MathMLOperatorDictionary::Fence);
    3682 }
    3683 
    3684 bool AccessibilityRenderObject::isMathSeparatorOperator() const
    3685 {
    3686     if (!is<RenderMathMLOperator>(m_renderer))
    3687         return false;
    3688 
    3689     return downcast<RenderMathMLOperator>(*m_renderer).hasOperatorFlag(MathMLOperatorDictionary::Separator);
    3690 }
    3691    
    3692 bool AccessibilityRenderObject::isMathText() const
    3693 {
    3694     return node() && (node()->hasTagName(MathMLNames::mtextTag) || hasTagName(MathMLNames::msTag));
    3695 }
    3696 
    3697 bool AccessibilityRenderObject::isMathNumber() const
    3698 {
    3699     return node() && node()->hasTagName(MathMLNames::mnTag);
    3700 }
    3701 
    3702 bool AccessibilityRenderObject::isMathIdentifier() const
    3703 {
    3704     return node() && node()->hasTagName(MathMLNames::miTag);
    3705 }
    3706 
    3707 bool AccessibilityRenderObject::isMathMultiscript() const
    3708 {
    3709     return node() && node()->hasTagName(MathMLNames::mmultiscriptsTag);
    3710 }
    3711    
    3712 bool AccessibilityRenderObject::isMathTable() const
    3713 {
    3714     return node() && node()->hasTagName(MathMLNames::mtableTag);
    3715 }
    3716 
    3717 bool AccessibilityRenderObject::isMathTableRow() const
    3718 {
    3719     return node() && (node()->hasTagName(MathMLNames::mtrTag) || hasTagName(MathMLNames::mlabeledtrTag));
    3720 }
    3721 
    3722 bool AccessibilityRenderObject::isMathTableCell() const
    3723 {
    3724     return node() && node()->hasTagName(MathMLNames::mtdTag);
    3725 }
    3726 
    3727 bool AccessibilityRenderObject::isMathScriptObject(AccessibilityMathScriptObjectType type) const
    3728 {
    3729     AccessibilityObject* parent = parentObjectUnignored();
    3730     if (!parent)
    3731         return false;
    3732 
    3733     return type == Subscript ? this == parent->mathSubscriptObject() : this == parent->mathSuperscriptObject();
    3734 }
    3735 
    3736 bool AccessibilityRenderObject::isMathMultiscriptObject(AccessibilityMathMultiscriptObjectType type) const
    3737 {
    3738     AccessibilityObject* parent = parentObjectUnignored();
    3739     if (!parent || !parent->isMathMultiscript())
    3740         return false;
    3741 
    3742     // The scripts in a MathML <mmultiscripts> element consist of one or more
    3743     // subscript, superscript pairs. In order to determine if this object is
    3744     // a scripted token, we need to examine each set of pairs to see if the
    3745     // this token is present and in the position corresponding with the type.
    3746 
    3747     AccessibilityMathMultiscriptPairs pairs;
    3748     if (type == PreSubscript || type == PreSuperscript)
    3749         parent->mathPrescripts(pairs);
    3750     else
    3751         parent->mathPostscripts(pairs);
    3752 
    3753     for (const auto& pair : pairs) {
    3754         if (this == pair.first)
    3755             return (type == PreSubscript || type == PostSubscript);
    3756         if (this == pair.second)
    3757             return (type == PreSuperscript || type == PostSuperscript);
    3758     }
    3759 
    3760     return false;
    3761 }
    3762    
    37633585bool AccessibilityRenderObject::isIgnoredElementWithinMathTree() const
    37643586{
    3765     if (!m_renderer)
    3766         return true;
    3767 
    3768     if (is<RenderText>(*m_renderer))
    3769         return false;
    3770 
    3771     // Only math elements that we explicitly recognize should be included
    3772     // We don't want things like <mstyle> to appear in the tree.
    3773     if (isMathElement()) {
    3774         if (isMathFraction() || isMathFenced() || isMathSubscriptSuperscript() || isMathRow()
    3775             || isMathUnderOver() || isMathRoot() || isMathText() || isMathNumber()
    3776             || isMathOperator() || isMathFenceOperator() || isMathSeparatorOperator()
    3777             || isMathIdentifier() || isMathTable() || isMathTableRow() || isMathTableCell() || isMathMultiscript())
    3778             return false;
    3779         return true;
    3780     }
    3781 
    3782     return m_renderer->isAnonymous() && m_renderer->parent() && is<RenderMathMLBlock>(m_renderer->parent());
    3783 }
    3784 
    3785 AccessibilityObject* AccessibilityRenderObject::mathRadicandObject()
    3786 {
    3787     if (!isMathRoot())
    3788         return nullptr;
    3789 
    3790     // For MathSquareRoot, we actually return the first child of the base.
    3791     // See also https://webkit.org/b/146452
    3792     const auto& children = this->children();
    3793     if (children.size() < 1)
    3794         return nullptr;
    3795 
    3796     return children[0].get();
    3797 }
    3798 
    3799 AccessibilityObject* AccessibilityRenderObject::mathRootIndexObject()
    3800 {
    3801     if (!isMathRoot() || isMathSquareRoot())
    3802         return nullptr;
    3803 
    3804     const auto& children = this->children();
    3805     if (children.size() < 2)
    3806         return nullptr;
    3807 
    3808     return children[1].get();
    3809 }
    3810 
    3811 AccessibilityObject* AccessibilityRenderObject::mathNumeratorObject()
    3812 {
    3813     if (!isMathFraction())
    3814         return nullptr;
    3815    
    3816     const auto& children = this->children();
    3817     if (children.size() != 2)
    3818         return nullptr;
    3819    
    3820     return children[0].get();
    3821 }
    3822    
    3823 AccessibilityObject* AccessibilityRenderObject::mathDenominatorObject()
    3824 {
    3825     if (!isMathFraction())
    3826         return nullptr;
    3827 
    3828     const auto& children = this->children();
    3829     if (children.size() != 2)
    3830         return nullptr;
    3831    
    3832     return children[1].get();
    3833 }
    3834    
    3835 AccessibilityObject* AccessibilityRenderObject::mathUnderObject()
    3836 {
    3837     if (!isMathUnderOver() || !node())
    3838         return nullptr;
    3839    
    3840     const auto& children = this->children();
    3841     if (children.size() < 2)
    3842         return nullptr;
    3843    
    3844     if (node()->hasTagName(MathMLNames::munderTag) || node()->hasTagName(MathMLNames::munderoverTag))
    3845         return children[1].get();
    3846    
    3847     return nullptr;
    3848 }
    3849 
    3850 AccessibilityObject* AccessibilityRenderObject::mathOverObject()
    3851 {
    3852     if (!isMathUnderOver() || !node())
    3853         return nullptr;
    3854    
    3855     const auto& children = this->children();
    3856     if (children.size() < 2)
    3857         return nullptr;
    3858    
    3859     if (node()->hasTagName(MathMLNames::moverTag))
    3860         return children[1].get();
    3861     if (node()->hasTagName(MathMLNames::munderoverTag))
    3862         return children[2].get();
    3863 
    3864     return nullptr;
    3865 }
    3866 
    3867 AccessibilityObject* AccessibilityRenderObject::mathBaseObject()
    3868 {
    3869     if (!isMathSubscriptSuperscript() && !isMathUnderOver() && !isMathMultiscript())
    3870         return nullptr;
    3871    
    3872     const auto& children = this->children();
    3873     // The base object in question is always the first child.
    3874     if (children.size() > 0)
    3875         return children[0].get();
    3876 
    3877     return nullptr;
    3878 }
    3879 
    3880 AccessibilityObject* AccessibilityRenderObject::mathSubscriptObject()
    3881 {
    3882     if (!isMathSubscriptSuperscript() || !node())
    3883         return nullptr;
    3884    
    3885     const auto& children = this->children();
    3886     if (children.size() < 2)
    3887         return nullptr;
    3888 
    3889     if (node()->hasTagName(MathMLNames::msubTag) || node()->hasTagName(MathMLNames::msubsupTag))
    3890         return children[1].get();
    3891    
    3892     return nullptr;
    3893 }
    3894 
    3895 AccessibilityObject* AccessibilityRenderObject::mathSuperscriptObject()
    3896 {
    3897     if (!isMathSubscriptSuperscript() || !node())
    3898         return nullptr;
    3899    
    3900     const auto& children = this->children();
    3901     unsigned count = children.size();
    3902 
    3903     if (count >= 2 && node()->hasTagName(MathMLNames::msupTag))
    3904         return children[1].get();
    3905 
    3906     if (count >= 3 && node()->hasTagName(MathMLNames::msubsupTag))
    3907         return children[2].get();
    3908    
    3909     return nullptr;
    3910 }
    3911    
    3912 String AccessibilityRenderObject::mathFencedOpenString() const
    3913 {
    3914     if (!isMathFenced())
    3915         return String();
    3916    
    3917     return getAttribute(MathMLNames::openAttr);
    3918 }
    3919 
    3920 String AccessibilityRenderObject::mathFencedCloseString() const
    3921 {
    3922     if (!isMathFenced())
    3923         return String();
    3924    
    3925     return getAttribute(MathMLNames::closeAttr);
    3926 }
    3927    
    3928 void AccessibilityRenderObject::mathPrescripts(AccessibilityMathMultiscriptPairs& prescripts)
    3929 {
    3930     if (!isMathMultiscript() || !node())
    3931         return;
    3932    
    3933     bool foundPrescript = false;
    3934     std::pair<AccessibilityObject*, AccessibilityObject*> prescriptPair;
    3935     for (Node* child = node()->firstChild(); child; child = child->nextSibling()) {
    3936         if (foundPrescript) {
    3937             AccessibilityObject* axChild = axObjectCache()->getOrCreate(child);
    3938             if (axChild && axChild->isMathElement()) {
    3939                 if (!prescriptPair.first)
    3940                     prescriptPair.first = axChild;
    3941                 else {
    3942                     prescriptPair.second = axChild;
    3943                     prescripts.append(prescriptPair);
    3944                     prescriptPair.first = nullptr;
    3945                     prescriptPair.second = nullptr;
    3946                 }
    3947             }
    3948         } else if (child->hasTagName(MathMLNames::mprescriptsTag))
    3949             foundPrescript = true;
    3950     }
    3951    
    3952     // Handle the odd number of pre scripts case.
    3953     if (prescriptPair.first)
    3954         prescripts.append(prescriptPair);
    3955 }
    3956 
    3957 void AccessibilityRenderObject::mathPostscripts(AccessibilityMathMultiscriptPairs& postscripts)
    3958 {
    3959     if (!isMathMultiscript() || !node())
    3960         return;
    3961 
    3962     // In Multiscripts, the post-script elements start after the first element (which is the base)
    3963     // and continue until a <mprescripts> tag is found
    3964     std::pair<AccessibilityObject*, AccessibilityObject*> postscriptPair;
    3965     bool foundBaseElement = false;
    3966     for (Node* child = node()->firstChild(); child; child = child->nextSibling()) {
    3967         if (child->hasTagName(MathMLNames::mprescriptsTag))
    3968             break;
    3969 
    3970         AccessibilityObject* axChild = axObjectCache()->getOrCreate(child);
    3971         if (axChild && axChild->isMathElement()) {
    3972             if (!foundBaseElement)
    3973                 foundBaseElement = true;
    3974             else if (!postscriptPair.first)
    3975                 postscriptPair.first = axChild;
    3976             else {
    3977                 postscriptPair.second = axChild;
    3978                 postscripts.append(postscriptPair);
    3979                 postscriptPair.first = nullptr;
    3980                 postscriptPair.second = nullptr;
    3981             }
    3982         }
    3983     }
    3984 
    3985     // Handle the odd number of post scripts case.
    3986     if (postscriptPair.first)
    3987         postscripts.append(postscriptPair);
    3988 }
    3989 
    3990 int AccessibilityRenderObject::mathLineThickness() const
    3991 {
    3992     if (!is<RenderMathMLFraction>(m_renderer))
    3993         return -1;
    3994    
    3995     return downcast<RenderMathMLFraction>(*m_renderer).relativeLineThickness();
    3996 }
    3997 
     3587    // We ignore anonymous boxes inserted into RenderMathMLBlocks to honor CSS rules.
     3588    // See https://www.w3.org/TR/css3-box/#block-level0
     3589    return m_renderer && m_renderer->isAnonymous() && m_renderer->parent() && is<RenderMathMLBlock>(m_renderer->parent());
     3590}
    39983591#endif
    39993592   

  • trunk/Source/WebCore/accessibility/AccessibilityRenderObject.h

    r202497 r202961  
    216216    bool computeAccessibilityIsIgnored() const override;
    217217
     218#if ENABLE(MATHML)
     219    virtual bool isIgnoredElementWithinMathTree() const;
     220#endif
     221
    218222    RenderObject* m_renderer;
    219223
    … …  
    280284
    281285    bool shouldGetTextFromNode(AccessibilityTextUnderElementMode) const;
    282 
    283 #if ENABLE(MATHML)
    284     // All math elements return true for isMathElement().
    285     bool isMathElement() const override;
    286     bool isMathFraction() const override;
    287     bool isMathFenced() const override;
    288     bool isMathSubscriptSuperscript() const override;
    289     bool isMathRow() const override;
    290     bool isMathUnderOver() const override;
    291     bool isMathRoot() const override;
    292     bool isMathSquareRoot() const override;
    293     bool isMathText() const override;
    294     bool isMathNumber() const override;
    295     bool isMathOperator() const override;
    296     bool isMathFenceOperator() const override;
    297     bool isMathSeparatorOperator() const override;
    298     bool isMathIdentifier() const override;
    299     bool isMathTable() const override;
    300     bool isMathTableRow() const override;
    301     bool isMathTableCell() const override;
    302     bool isMathMultiscript() const override;
    303     bool isMathToken() const override;
    304     bool isMathScriptObject(AccessibilityMathScriptObjectType) const override;
    305     bool isMathMultiscriptObject(AccessibilityMathMultiscriptObjectType) const override;
    306    
    307     // Generic components.
    308     AccessibilityObject* mathBaseObject() override;
    309    
    310     // Root components.
    311     AccessibilityObject* mathRadicandObject() override;
    312     AccessibilityObject* mathRootIndexObject() override;
    313    
    314     // Fraction components.
    315     AccessibilityObject* mathNumeratorObject() override;
    316     AccessibilityObject* mathDenominatorObject() override;
    317 
    318     // Under over components.
    319     AccessibilityObject* mathUnderObject() override;
    320     AccessibilityObject* mathOverObject() override;
    321    
    322     // Subscript/superscript components.
    323     AccessibilityObject* mathSubscriptObject() override;
    324     AccessibilityObject* mathSuperscriptObject() override;
    325    
    326     // Fenced components.
    327     String mathFencedOpenString() const override;
    328     String mathFencedCloseString() const override;
    329     int mathLineThickness() const override;
    330     bool isAnonymousMathOperator() const override;
    331 
    332     // Multiscripts components.
    333     void mathPrescripts(AccessibilityMathMultiscriptPairs&) override;
    334     void mathPostscripts(AccessibilityMathMultiscriptPairs&) override;
    335    
    336     bool isIgnoredElementWithinMathTree() const;
    337 #endif
    338286};
    339287
Note: See TracChangeset for help on using the changeset viewer.