Changeset 195405 in webkit


Ignore:
Timestamp:
Jan 21, 2016 12:35:10 AM (8 years ago)
Author:
n_wang@apple.com
Message:

AX: [IOS] Implement next/previous text marker functions using TextIterator
​https://bugs.webkit.org/show_bug.cgi?id=153292
<rdar://problem/24268243>

Reviewed by Chris Fleizach.

Source/WebCore:

Added support for the refactored next/previous text marker functions on iOS. And
made text marker tests working on iOS.
Also, fixed an issue in AXObjectCache where creating a range with a replaced node
at the start or end might exclude that node.

Tests: accessibility/text-marker/text-marker-previous-next.html

accessibility/text-marker/text-marker-with-user-select-none.html

  • accessibility/AXObjectCache.cpp:

(WebCore::characterOffsetsInOrder):
(WebCore::resetNodeAndOffsetForReplacedNode):
(WebCore::AXObjectCache::rangeForUnorderedCharacterOffsets):

  • accessibility/ios/WebAccessibilityObjectWrapperIOS.mm:

(+[WebAccessibilityTextMarker textMarkerWithVisiblePosition:cache:]):
(+[WebAccessibilityTextMarker textMarkerWithCharacterOffset:cache:]):
(+[WebAccessibilityTextMarker startOrEndTextMarkerForRange:isStart:cache:]):
(-[WebAccessibilityTextMarker dataRepresentation]):
(-[WebAccessibilityTextMarker visiblePosition]):
(-[WebAccessibilityTextMarker characterOffset]):
(-[WebAccessibilityTextMarker isIgnored]):
(-[WebAccessibilityTextMarker accessibilityObject]):
(-[WebAccessibilityTextMarker description]):
(-[WebAccessibilityObjectWrapper stringForTextMarkers:]):
(blockquoteLevel):
(-[WebAccessibilityObjectWrapper textMarkerRange]):
(-[WebAccessibilityObjectWrapper accessibilityObjectForTextMarker:]):
(-[WebAccessibilityObjectWrapper nextMarkerForMarker:]):
(-[WebAccessibilityObjectWrapper previousMarkerForMarker:]):
(-[WebAccessibilityObjectWrapper textMarkerForPoint:]):
(-[WebAccessibilityObjectWrapper nextMarkerForCharacterOffset:]):
(-[WebAccessibilityObjectWrapper previousMarkerForCharacterOffset:]):
(-[WebAccessibilityObjectWrapper rangeForTextMarkers:]):
(-[WebAccessibilityObjectWrapper lengthForTextMarkers:]):
(-[WebAccessibilityObjectWrapper startOrEndTextMarkerForTextMarkers:isStart:]):
(-[WebAccessibilityObjectWrapper textMarkerRangeForMarkers:]):
(-[WebAccessibilityObjectWrapper accessibilityIdentifier]):

Tools:

Made text marker tests available on iOS.

  • DumpRenderTree/AccessibilityTextMarker.h:
  • DumpRenderTree/DumpRenderTree.xcodeproj/project.pbxproj:
  • DumpRenderTree/ios/AccessibilityTextMarkerIOS.mm: Added.

(AccessibilityTextMarker::AccessibilityTextMarker):
(AccessibilityTextMarker::~AccessibilityTextMarker):
(AccessibilityTextMarker::isEqual):
(AccessibilityTextMarker::platformTextMarker):
(AccessibilityTextMarkerRange::AccessibilityTextMarkerRange):
(AccessibilityTextMarkerRange::~AccessibilityTextMarkerRange):
(AccessibilityTextMarkerRange::isEqual):
(AccessibilityTextMarkerRange::platformTextMarkerRange):

  • DumpRenderTree/ios/AccessibilityUIElementIOS.mm:

(AccessibilityUIElement::pathDescription):
(AccessibilityUIElement::lineTextMarkerRangeForTextMarker):
(AccessibilityUIElement::textMarkerRangeForElement):
(AccessibilityUIElement::selectedTextMarkerRange):
(AccessibilityUIElement::resetSelectedTextMarkerRange):
(AccessibilityUIElement::textMarkerRangeLength):
(AccessibilityUIElement::textMarkerRangeForMarkers):
(AccessibilityUIElement::startTextMarkerForTextMarkerRange):
(AccessibilityUIElement::endTextMarkerForTextMarkerRange):
(AccessibilityUIElement::accessibilityElementForTextMarker):
(AccessibilityUIElement::endTextMarkerForBounds):
(AccessibilityUIElement::startTextMarkerForBounds):
(AccessibilityUIElement::textMarkerForPoint):
(AccessibilityUIElement::previousTextMarker):
(AccessibilityUIElement::nextTextMarker):
(AccessibilityUIElement::stringForTextMarkerRange):
(AccessibilityUIElement::attributedStringForTextMarkerRangeContainsAttribute):
(AccessibilityUIElement::indexForTextMarker):
(AccessibilityUIElement::isTextMarkerValid):
(AccessibilityUIElement::textMarkerForIndex):
(AccessibilityUIElement::startTextMarker):
(AccessibilityUIElement::endTextMarker):
(AccessibilityUIElement::setSelectedVisibleTextRange):
(AccessibilityUIElement::getLinkedUIElements):

  • DumpRenderTree/mac/AccessibilityTextMarkerMac.mm:

(AccessibilityTextMarkerRange::platformTextMarkerRange):

  • DumpRenderTree/mac/AccessibilityUIElementMac.mm:

(AccessibilityUIElement::removeSelection):
(AccessibilityUIElement::lineTextMarkerRangeForTextMarker):
(AccessibilityUIElement::setSelectedVisibleTextRange):
(AccessibilityUIElement::supportedActions):

  • WebKitTestRunner/InjectedBundle/ios/AccessibilityUIElementIOS.mm:

(WTR::AccessibilityUIElement::textMarkerRangeForElement):
(WTR::AccessibilityUIElement::textMarkerRangeLength):
(WTR::AccessibilityUIElement::previousTextMarker):
(WTR::AccessibilityUIElement::nextTextMarker):
(WTR::AccessibilityUIElement::stringForTextMarkerRange):
(WTR::AccessibilityUIElement::textMarkerRangeForMarkers):
(WTR::AccessibilityUIElement::startTextMarkerForTextMarkerRange):
(WTR::AccessibilityUIElement::endTextMarkerForTextMarkerRange):
(WTR::AccessibilityUIElement::endTextMarkerForBounds):
(WTR::AccessibilityUIElement::accessibilityElementForTextMarker):
(WTR::AccessibilityUIElement::attributedStringForTextMarkerRangeContainsAttribute):

LayoutTests:

  • accessibility/mac/previous-next-text-marker-expected.txt: Removed.
  • accessibility/mac/previous-next-text-marker.html: Removed.
  • accessibility/mac/text-marker-with-user-select-none-expected.txt: Removed.
  • accessibility/mac/text-marker-with-user-select-none.html: Removed.
  • accessibility/text-marker: Added.
  • accessibility/text-marker/text-marker-previous-next-expected.txt: Added.
  • accessibility/text-marker/text-marker-previous-next.html: Added.
  • accessibility/text-marker/text-marker-with-user-select-none-expected.txt: Added.
  • accessibility/text-marker/text-marker-with-user-select-none.html: Added.
  • platform/efl/TestExpectations:
  • platform/gtk/TestExpectations:
  • platform/ios-simulator/TestExpectations:
  • platform/win/TestExpectations:
Location:
trunk
Files:
1 added
15 edited
1 copied
4 moved

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r195397 r195405  
     12016-01-21  Nan Wang  <n_wang@apple.com>
     2
     3        AX: [IOS] Implement next/previous text marker functions using TextIterator
     4        https://bugs.webkit.org/show_bug.cgi?id=153292
     5        <rdar://problem/24268243>
     6
     7        Reviewed by Chris Fleizach.
     8
     9        * accessibility/mac/previous-next-text-marker-expected.txt: Removed.
     10        * accessibility/mac/previous-next-text-marker.html: Removed.
     11        * accessibility/mac/text-marker-with-user-select-none-expected.txt: Removed.
     12        * accessibility/mac/text-marker-with-user-select-none.html: Removed.
     13        * accessibility/text-marker: Added.
     14        * accessibility/text-marker/text-marker-previous-next-expected.txt: Added.
     15        * accessibility/text-marker/text-marker-previous-next.html: Added.
     16        * accessibility/text-marker/text-marker-with-user-select-none-expected.txt: Added.
     17        * accessibility/text-marker/text-marker-with-user-select-none.html: Added.
     18        * platform/efl/TestExpectations:
     19        * platform/gtk/TestExpectations:
     20        * platform/ios-simulator/TestExpectations:
     21        * platform/win/TestExpectations:
     22
    1232016-01-20  Zalan Bujtas  <zalan@apple.com>
    224

  • trunk/LayoutTests/accessibility/text-marker/text-marker-previous-next-expected.txt

    r195398 r195405  
    1313PASS text.accessibilityElementForTextMarker(startMarker).isEqual(text) is true
    1414PASS text.accessibilityElementForTextMarker(endMarker).isEqual(text) is true
    15 PASS element.stringValue is 'AXValue: '
    16 PASS element.stringValue is 'AXValue: text1'
    17 PASS element.stringValue is 'AXValue: '
    18 PASS element.stringValue is 'AXValue: text'
     15PASS text.stringForTextMarkerRange(markerRange) is ''
     16PASS text.stringForTextMarkerRange(markerRange) is 't'
     17PASS text.stringForTextMarkerRange(markerRange) is ''
     18PASS text.stringForTextMarkerRange(markerRange) is 't'
    1919PASS text2.textMarkerRangeLength(textMarkerRange2) is 5
    2020Object string for range: c [ATTACHMENT] d
    21 AXValue: c
    22 AXValue: c
    23 AXValue:
    24 AXValue:  d
    25 AXValue:
    26 AXValue: c
    27 AXValue: c
    28 AXValue: text1
     21PASS text2.stringForTextMarkerRange(markerRange) is 'd'
     22PASS text2.stringForTextMarkerRange(markerRange) is '1'
    2923PASS text3.stringForTextMarkerRange(markerRange) is 'ect'
    3024PASS text3.stringForTextMarkerRange(markerRange) is 'sel'

  • trunk/LayoutTests/accessibility/text-marker/text-marker-previous-next.html

    r195398 r195405  
    4545        // Check next text marker. (Advance 5 characters, it will land at <br>.)
    4646        var currentMarker = startMarker;
     47        var previousMarker, markerRange;
    4748        for (var i = 0; i < 5; i++) {
     49            previousMarker = currentMarker;
    4850            currentMarker = text.nextTextMarker(currentMarker);
    4951        }
    50         var element = text.accessibilityElementForTextMarker(currentMarker);
    51         shouldBe("element.stringValue", "'AXValue: '");
     52        markerRange = text.textMarkerRangeForMarkers(previousMarker, currentMarker);
     53        shouldBe("text.stringForTextMarkerRange(markerRange)", "''");
    5254       
    5355        // Advance one more character, it will lande at "t" in "text1".
     56        previousMarker = currentMarker;
    5457        currentMarker = text.nextTextMarker(currentMarker);
    55         element = text.accessibilityElementForTextMarker(currentMarker);
    56         shouldBe("element.stringValue", "'AXValue: text1'");
     58        markerRange = text.textMarkerRangeForMarkers(previousMarker, currentMarker);
     59        shouldBe("text.stringForTextMarkerRange(markerRange)", "'t'");
    5760       
    5861        // Check previous text marker. (Traverse backwards one character, it will land at <br>.)
     62        previousMarker = text.previousTextMarker(previousMarker);
    5963        currentMarker = text.previousTextMarker(currentMarker);
    60         element = text.accessibilityElementForTextMarker(currentMarker);
    61         shouldBe("element.stringValue", "'AXValue: '");
     64        markerRange = text.textMarkerRangeForMarkers(previousMarker, currentMarker);
     65        shouldBe("text.stringForTextMarkerRange(markerRange)", "''");
    6266       
    6367        // Traverse backwards one more character, it will land at the last character of "text".
     68        previousMarker = text.previousTextMarker(previousMarker);
    6469        currentMarker = text.previousTextMarker(currentMarker);
    65         element = text.accessibilityElementForTextMarker(currentMarker);
    66         shouldBe("element.stringValue", "'AXValue: text'");
     70        markerRange = text.textMarkerRangeForMarkers(previousMarker, currentMarker);
     71        shouldBe("text.stringForTextMarkerRange(markerRange)", "'t'");
    6772       
    6873        // Check the case with replaced node
    … …  
    7479       
    7580        currentMarker = text2.startTextMarkerForTextMarkerRange(textMarkerRange2);
    76         // Advance 4 characters, it will land at first character of " d".
    77         for (var i = 0; i < 4; i++) {
     81        // Advance 5 characters, it will land at "d".
     82        for (var i = 0; i < 5; i++) {
     83            previousMarker = currentMarker;
    7884            currentMarker = text2.nextTextMarker(currentMarker);
    79             element = text2.accessibilityElementForTextMarker(currentMarker);
    80             debug(element.stringValue);
    8185        }
     86        markerRange = text2.textMarkerRangeForMarkers(previousMarker, currentMarker);
     87        shouldBe("text2.stringForTextMarkerRange(markerRange)", "'d'");
    8288       
    83         // Traverse backwards 4 characters, it will land at the last character of "text1".
    84         for (var i = 0; i < 4; i++) {
     89        // Traverse backwards 5 characters, it will land at the last character of "text1".
     90        for (var i = 0; i < 5; i++) {
     91            previousMarker = text2.previousTextMarker(previousMarker);
    8592            currentMarker = text2.previousTextMarker(currentMarker);
    86             element = text2.accessibilityElementForTextMarker(currentMarker);
    87             debug(element.stringValue);
    8893        }
     94        markerRange = text2.textMarkerRangeForMarkers(previousMarker, currentMarker);
     95        shouldBe("text2.stringForTextMarkerRange(markerRange)", "'1'");
    8996       
    9097        // Check the case with user-select:none, nextTextMarker/previousTextMarker should still work.
    … …  
    101108        }
    102109        marker2 = currentMarker;
    103         var markerRange = text3.textMarkerRangeForMarkers(marker1, marker2);
     110        markerRange = text3.textMarkerRangeForMarkers(marker1, marker2);
    104111        shouldBe("text3.stringForTextMarkerRange(markerRange)", "'ect'");
    105112        // Iterate backwards the second marker for 6 characters, the range should be "sel"

  • trunk/LayoutTests/platform/efl/TestExpectations

    r194672 r195405  
    23462346webkit.org/b/146887 accessibility/aria-roledescription.html [ Failure ]
    23472347webkit.org/b/146887 accessibility/list-detection.html [ Failure ]
     2348
     2349# Text marker tests are not supported
     2350webkit.org/b/153292 accessibility/text-marker [ Skip ]
    23482351
    23492352# This test hardcodes the result of a platform-dependent font lookup algorithm.

  • trunk/LayoutTests/platform/gtk/TestExpectations

    r194962 r195405  
    609609# ARIA 1.1 table related attributes are not supported
    610610webkit.org/b/148967 accessibility/aria-table-attributes.html [ Skip ]
     611
     612# Text marker tests are not supported
     613webkit.org/b/153292 accessibility/text-marker [ Skip ]
    611614
    612615# WebKitGTK+ needs WOFF2 support.

  • trunk/LayoutTests/platform/ios-simulator/TestExpectations

    r195382 r195405  
    27652765webkit.org/b/150366 accessibility/aria-table-attributes.html [ Pass ]
    27662766
     2767# Enable Text marker tests for iOS
     2768webkit.org/b/153292 accessibility/text-marker [ Pass ]
     2769
    27672770# More flaky tests (Sept 18, 2015)
    27682771

  • trunk/LayoutTests/platform/win/TestExpectations

    r194672 r195405  
    17181718webkit.org/b/138566 accessibility/aria-modal.html [ Skip ]
    17191719webkit.org/b/138566 accessibility/aria-modal-multiple-dialogs.html [ Skip ]
     1720
     1721# Text marker tests are not supported
     1722webkit.org/b/153292 accessibility/text-marker [ Skip ]
    17201723
    17211724################################################################################

  • trunk/Source/WebCore/ChangeLog

    r195397 r195405  
     12016-01-21  Nan Wang  <n_wang@apple.com>
     2
     3        AX: [IOS] Implement next/previous text marker functions using TextIterator
     4        https://bugs.webkit.org/show_bug.cgi?id=153292
     5        <rdar://problem/24268243>
     6
     7        Reviewed by Chris Fleizach.
     8
     9        Added support for the refactored next/previous text marker functions on iOS. And
     10        made text marker tests working on iOS.
     11        Also, fixed an issue in AXObjectCache where creating a range with a replaced node
     12        at the start or end might exclude that node.
     13
     14        Tests: accessibility/text-marker/text-marker-previous-next.html
     15               accessibility/text-marker/text-marker-with-user-select-none.html
     16
     17        * accessibility/AXObjectCache.cpp:
     18        (WebCore::characterOffsetsInOrder):
     19        (WebCore::resetNodeAndOffsetForReplacedNode):
     20        (WebCore::AXObjectCache::rangeForUnorderedCharacterOffsets):
     21        * accessibility/ios/WebAccessibilityObjectWrapperIOS.mm:
     22        (+[WebAccessibilityTextMarker textMarkerWithVisiblePosition:cache:]):
     23        (+[WebAccessibilityTextMarker textMarkerWithCharacterOffset:cache:]):
     24        (+[WebAccessibilityTextMarker startOrEndTextMarkerForRange:isStart:cache:]):
     25        (-[WebAccessibilityTextMarker dataRepresentation]):
     26        (-[WebAccessibilityTextMarker visiblePosition]):
     27        (-[WebAccessibilityTextMarker characterOffset]):
     28        (-[WebAccessibilityTextMarker isIgnored]):
     29        (-[WebAccessibilityTextMarker accessibilityObject]):
     30        (-[WebAccessibilityTextMarker description]):
     31        (-[WebAccessibilityObjectWrapper stringForTextMarkers:]):
     32        (blockquoteLevel):
     33        (-[WebAccessibilityObjectWrapper textMarkerRange]):
     34        (-[WebAccessibilityObjectWrapper accessibilityObjectForTextMarker:]):
     35        (-[WebAccessibilityObjectWrapper nextMarkerForMarker:]):
     36        (-[WebAccessibilityObjectWrapper previousMarkerForMarker:]):
     37        (-[WebAccessibilityObjectWrapper textMarkerForPoint:]):
     38        (-[WebAccessibilityObjectWrapper nextMarkerForCharacterOffset:]):
     39        (-[WebAccessibilityObjectWrapper previousMarkerForCharacterOffset:]):
     40        (-[WebAccessibilityObjectWrapper rangeForTextMarkers:]):
     41        (-[WebAccessibilityObjectWrapper lengthForTextMarkers:]):
     42        (-[WebAccessibilityObjectWrapper startOrEndTextMarkerForTextMarkers:isStart:]):
     43        (-[WebAccessibilityObjectWrapper textMarkerRangeForMarkers:]):
     44        (-[WebAccessibilityObjectWrapper accessibilityIdentifier]):
     45
    1462016-01-20  Zalan Bujtas  <zalan@apple.com>
    247

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

    r195240 r195405  
    15461546}
    15471547
     1548static Node* resetNodeAndOffsetForReplacedNode(Node* replacedNode, int& offset, int characterCount)
     1549{
     1550    // Use this function to include the replaced node itself in the range we are creating.
     1551    if (!replacedNode)
     1552        return nullptr;
     1553   
     1554    RefPtr<Range> nodeRange = AXObjectCache::rangeForNodeContents(replacedNode);
     1555    int nodeLength = TextIterator::rangeLength(nodeRange.get());
     1556    offset = characterCount <= nodeLength ? replacedNode->computeNodeIndex() : replacedNode->computeNodeIndex() + 1;
     1557    return replacedNode->parentNode();
     1558}
     1559
     1560static bool isReplacedNodeOrBR(Node* node)
     1561{
     1562    return AccessibilityObject::replacedNodeNeedsCharacter(node) || node->hasTagName(brTag);
     1563}
     1564
    15481565RefPtr<Range> AXObjectCache::rangeForUnorderedCharacterOffsets(const CharacterOffset& characterOffset1, const CharacterOffset& characterOffset2)
    15491566{
    … …  
    15551572    CharacterOffset endCharacterOffset = alreadyInOrder ? characterOffset2 : characterOffset1;
    15561573   
    1557     int endOffset = endCharacterOffset.offset;
    1558    
    1559     // endOffset can be out of bounds sometimes if the node is a replaced node or has brTag.
    1560     if (startCharacterOffset.node == endCharacterOffset.node) {
    1561         RefPtr<Range> nodeRange = AXObjectCache::rangeForNodeContents(startCharacterOffset.node);
    1562         int nodeLength = TextIterator::rangeLength(nodeRange.get());
    1563         if (endOffset > nodeLength)
    1564             endOffset = nodeLength;
    1565     }
    1566    
    15671574    int startOffset = startCharacterOffset.startIndex + startCharacterOffset.offset;
    1568     endOffset = endCharacterOffset.startIndex + endOffset;
    1569    
    1570     // If start node is a replaced node and it has children, we want to include the replaced node itself in the range.
     1575    int endOffset = endCharacterOffset.startIndex + endCharacterOffset.offset;
    15711576    Node* startNode = startCharacterOffset.node;
    1572     if (AccessibilityObject::replacedNodeNeedsCharacter(startNode) && (startNode->hasChildNodes() || startNode != endCharacterOffset.node)) {
    1573         startOffset = startNode->computeNodeIndex();
    1574         startNode = startNode->parentNode();
     1577    Node* endNode = endCharacterOffset.node;
     1578   
     1579    // Consider the case when the replaced node is at the start/end of the range.
     1580    bool startNodeIsReplacedOrBR = isReplacedNodeOrBR(startNode);
     1581    bool endNodeIsReplacedOrBR = isReplacedNodeOrBR(endNode);
     1582    if (startNodeIsReplacedOrBR || endNodeIsReplacedOrBR) {
     1583        // endOffset can be out of bounds sometimes if the node is a replaced node or has brTag and it has no children.
     1584        if (startNode == endNode && !startNode->hasChildNodes()) {
     1585            RefPtr<Range> nodeRange = AXObjectCache::rangeForNodeContents(startNode);
     1586            int nodeLength = TextIterator::rangeLength(nodeRange.get());
     1587            if (endCharacterOffset.offset > nodeLength)
     1588                endOffset = endCharacterOffset.startIndex + nodeLength;
     1589        } else {
     1590            if (startNodeIsReplacedOrBR)
     1591                startNode = resetNodeAndOffsetForReplacedNode(startNode, startOffset, startCharacterOffset.offset);
     1592            if (endNodeIsReplacedOrBR)
     1593                endNode = resetNodeAndOffsetForReplacedNode(startNode, endOffset, startCharacterOffset.offset);
     1594        }
    15751595    }
    15761596   
    … …  
    15781598    ExceptionCode ecStart = 0, ecEnd = 0;
    15791599    result->setStart(startNode, startOffset, ecStart);
    1580     result->setEnd(endCharacterOffset.node, endOffset, ecEnd);
     1600    result->setEnd(endNode, endOffset, ecEnd);
    15811601    if (ecStart || ecEnd)
    15821602        return nullptr;

  • trunk/Source/WebCore/accessibility/ios/WebAccessibilityObjectWrapperIOS.mm

    r194054 r195405  
    135135
    136136+ (WebAccessibilityTextMarker *)textMarkerWithVisiblePosition:(VisiblePosition&)visiblePos cache:(AXObjectCache*)cache;
     137+ (WebAccessibilityTextMarker *)textMarkerWithCharacterOffset:(CharacterOffset&)characterOffset cache:(AXObjectCache*)cache;
     138+ (WebAccessibilityTextMarker *)startOrEndTextMarkerForRange:(const RefPtr<Range>)range isStart:(BOOL)isStart cache:(AXObjectCache*)cache;
    137139
    138140@end
    … …  
    179181}
    180182
     183+ (WebAccessibilityTextMarker *)textMarkerWithCharacterOffset:(CharacterOffset&)characterOffset cache:(AXObjectCache*)cache
     184{
     185    if (!cache)
     186        return nil;
     187   
     188    if (characterOffset.isNull())
     189        return nil;
     190   
     191    TextMarkerData textMarkerData;
     192    cache->textMarkerDataForCharacterOffset(textMarkerData, *characterOffset.node, characterOffset.offset, false);
     193    if (!textMarkerData.axID && !textMarkerData.ignored)
     194        return nil;
     195    return [[[WebAccessibilityTextMarker alloc] initWithTextMarker:&textMarkerData cache:cache] autorelease];
     196}
     197
     198+ (WebAccessibilityTextMarker *)startOrEndTextMarkerForRange:(const RefPtr<Range>)range isStart:(BOOL)isStart cache:(AXObjectCache*)cache
     199{
     200    if (!cache)
     201        return nil;
     202   
     203    TextMarkerData textMarkerData;
     204    cache->startOrEndTextMarkerDataForRange(textMarkerData, range, isStart);
     205    if (!textMarkerData.axID)
     206        return nil;
     207    return [[[WebAccessibilityTextMarker alloc] initWithTextMarker:&textMarkerData cache:cache] autorelease];
     208}
     209
    181210- (NSData *)dataRepresentation
    182211{
    … …  
    187216{
    188217    return _cache->visiblePositionForTextMarkerData(_textMarkerData);
     218}
     219
     220- (CharacterOffset)characterOffset
     221{
     222    if (_textMarkerData.ignored)
     223        return CharacterOffset();
     224    return CharacterOffset(_textMarkerData.node, _textMarkerData.characterStartIndex, _textMarkerData.characterOffset);
     225}
     226
     227- (BOOL)isIgnored
     228{
     229    return _textMarkerData.ignored;
     230}
     231
     232- (AccessibilityObject*)accessibilityObject
     233{
     234    if (_textMarkerData.ignored)
     235        return nullptr;
     236    return _cache->accessibilityObjectForTextMarkerData(_textMarkerData);
    189237}
    190238
    … …  
    18321880        return nil;
    18331881   
    1834     if ([markers count] != 2)
    1835         return nil;
    1836    
    1837     WebAccessibilityTextMarker* startMarker = [markers objectAtIndex:0];
    1838     WebAccessibilityTextMarker* endMarker = [markers objectAtIndex:1];
    1839     if (![startMarker isKindOfClass:[WebAccessibilityTextMarker class]] || ![endMarker isKindOfClass:[WebAccessibilityTextMarker class]])
    1840         return nil;
    1841    
    1842     // extract the start and end VisiblePosition
    1843     VisiblePosition startVisiblePosition = [startMarker visiblePosition];
    1844     if (startVisiblePosition.isNull())
    1845         return nil;
    1846    
    1847     VisiblePosition endVisiblePosition = [endMarker visiblePosition];
    1848     if (endVisiblePosition.isNull())
    1849         return nil;
    1850 
    1851     VisiblePositionRange visiblePosRange = VisiblePositionRange(startVisiblePosition, endVisiblePosition);
    1852     return m_object->stringForVisiblePositionRange(visiblePosRange);
     1882    RefPtr<Range> range = [self rangeForTextMarkers:markers];
     1883    if (!range)
     1884        return nil;
     1885   
     1886    return m_object->stringForRange(range);
    18531887}
    18541888
    … …  
    21252159        return nil;
    21262160   
    2127     VisiblePositionRange range = m_object->visiblePositionRange();
    2128     VisiblePosition startPosition = range.start;
    2129     VisiblePosition endPosition = range.end;
    2130     WebAccessibilityTextMarker* start = [WebAccessibilityTextMarker textMarkerWithVisiblePosition:startPosition cache:m_object->axObjectCache()];
    2131     WebAccessibilityTextMarker* end = [WebAccessibilityTextMarker textMarkerWithVisiblePosition:endPosition cache:m_object->axObjectCache()];
    2132    
    2133     return [NSArray arrayWithObjects:start, end, nil];
     2161    RefPtr<Range> range = m_object->elementRange();
     2162    return [self textMarkersForRange:range];
    21342163}
    21352164
    … …  
    21612190        return nil;
    21622191   
    2163     VisiblePosition visiblePosition = [marker visiblePosition];
    2164     AccessibilityObject* obj = m_object->accessibilityObjectForPosition(visiblePosition);
     2192    AccessibilityObject* obj = [marker accessibilityObject];
    21652193    if (!obj)
    21662194        return nil;
    … …  
    23552383        return nil;
    23562384   
    2357     VisiblePosition start = [marker visiblePosition];
    2358     VisiblePosition nextMarker = m_object->nextVisiblePosition(start);
    2359    
    2360     return [WebAccessibilityTextMarker textMarkerWithVisiblePosition:nextMarker cache:m_object->axObjectCache()];
    2361 }
    2362 
    2363 // This method is intended to return the marker at the start of the line starting at
    2364 // the marker that is passed into the method.
     2385    CharacterOffset start = [marker characterOffset];
     2386    return [self nextMarkerForCharacterOffset:start];
     2387}
     2388
    23652389- (WebAccessibilityTextMarker *)previousMarkerForMarker:(WebAccessibilityTextMarker *)marker
    23662390{
    … …  
    23712395        return nil;
    23722396   
    2373     VisiblePosition start = [marker visiblePosition];
    2374     VisiblePosition previousMarker = m_object->previousVisiblePosition(start);
    2375    
    2376     return [WebAccessibilityTextMarker textMarkerWithVisiblePosition:previousMarker cache:m_object->axObjectCache()];
     2397    CharacterOffset start = [marker characterOffset];
     2398    return [self previousMarkerForCharacterOffset:start];
    23772399}
    23782400
    … …  
    24022424    VisiblePosition pos = m_object->visiblePositionForPoint(IntPoint(point));
    24032425    return [WebAccessibilityTextMarker textMarkerWithVisiblePosition:pos cache:m_object->axObjectCache()];
     2426}
     2427
     2428- (WebAccessibilityTextMarker *)nextMarkerForCharacterOffset:(CharacterOffset&)characterOffset
     2429{
     2430    characterOffset.offset = characterOffset.offset + 1;
     2431    WebAccessibilityTextMarker *textMarker = [WebAccessibilityTextMarker textMarkerWithCharacterOffset:characterOffset cache:m_object->axObjectCache()];
     2432    if (textMarker && textMarker.isIgnored)
     2433        textMarker = [self nextMarkerForCharacterOffset:characterOffset];
     2434    return textMarker;
     2435}
     2436
     2437- (WebAccessibilityTextMarker *)previousMarkerForCharacterOffset:(CharacterOffset&)characterOffset
     2438{
     2439    characterOffset.offset = characterOffset.offset - 1;
     2440    WebAccessibilityTextMarker *textMarker = [WebAccessibilityTextMarker textMarkerWithCharacterOffset:characterOffset cache:m_object->axObjectCache()];
     2441    if (textMarker && textMarker.isIgnored)
     2442        textMarker = [self previousMarkerForCharacterOffset:characterOffset];
     2443    return textMarker;
     2444}
     2445
     2446- (RefPtr<Range>)rangeForTextMarkers:(NSArray *)textMarkers
     2447{
     2448    if ([textMarkers count] != 2)
     2449        return nullptr;
     2450   
     2451    WebAccessibilityTextMarker *startMarker = [textMarkers objectAtIndex:0];
     2452    WebAccessibilityTextMarker *endMarker = [textMarkers objectAtIndex:1];
     2453   
     2454    if (![startMarker isKindOfClass:[WebAccessibilityTextMarker class]] || ![endMarker isKindOfClass:[WebAccessibilityTextMarker class]])
     2455        return nullptr;
     2456   
     2457    AXObjectCache* cache = m_object->axObjectCache();
     2458    if (!cache)
     2459        return nullptr;
     2460   
     2461    CharacterOffset startCharacterOffset = [startMarker characterOffset];
     2462    CharacterOffset endCharacterOffset = [endMarker characterOffset];
     2463    return cache->rangeForUnorderedCharacterOffsets(startCharacterOffset, endCharacterOffset);
     2464}
     2465
     2466- (NSInteger)lengthForTextMarkers:(NSArray *)textMarkers
     2467{
     2468    if (![self _prepareAccessibilityCall])
     2469        return 0;
     2470   
     2471    RefPtr<Range> range = [self rangeForTextMarkers:textMarkers];
     2472    int length = AXObjectCache::lengthForRange(range.get());
     2473    return length < 0 ? 0 : length;
     2474}
     2475
     2476- (WebAccessibilityTextMarker *)startOrEndTextMarkerForTextMarkers:(NSArray *)textMarkers isStart:(BOOL)isStart
     2477{
     2478    if (![self _prepareAccessibilityCall])
     2479        return nil;
     2480   
     2481    RefPtr<Range> range = [self rangeForTextMarkers:textMarkers];
     2482    if (!range)
     2483        return nil;
     2484   
     2485    return [WebAccessibilityTextMarker startOrEndTextMarkerForRange:range isStart:isStart cache:m_object->axObjectCache()];
     2486}
     2487
     2488- (NSArray *)textMarkerRangeForMarkers:(NSArray *)textMarkers
     2489{
     2490    if (![self _prepareAccessibilityCall])
     2491        return nil;
     2492   
     2493    RefPtr<Range> range = [self rangeForTextMarkers:textMarkers];
     2494    return [self textMarkersForRange:range];
     2495}
     2496
     2497- (NSArray *)textMarkersForRange:(RefPtr<Range>)range
     2498{
     2499    if (!range)
     2500        return nil;
     2501   
     2502    WebAccessibilityTextMarker* start = [WebAccessibilityTextMarker startOrEndTextMarkerForRange:range isStart:YES cache:m_object->axObjectCache()];
     2503    WebAccessibilityTextMarker* end = [WebAccessibilityTextMarker startOrEndTextMarkerForRange:range isStart:NO cache:m_object->axObjectCache()];
     2504    if (!start || !end)
     2505        return nil;
     2506    return [NSArray arrayWithObjects:start, end, nil];
    24042507}
    24052508

  • trunk/Tools/ChangeLog

    r195396 r195405  
     12016-01-21  Nan Wang  <n_wang@apple.com>
     2
     3        AX: [IOS] Implement next/previous text marker functions using TextIterator
     4        https://bugs.webkit.org/show_bug.cgi?id=153292
     5        <rdar://problem/24268243>
     6
     7        Reviewed by Chris Fleizach.
     8
     9        Made text marker tests available on iOS.
     10
     11        * DumpRenderTree/AccessibilityTextMarker.h:
     12        * DumpRenderTree/DumpRenderTree.xcodeproj/project.pbxproj:
     13        * DumpRenderTree/ios/AccessibilityTextMarkerIOS.mm: Added.
     14        (AccessibilityTextMarker::AccessibilityTextMarker):
     15        (AccessibilityTextMarker::~AccessibilityTextMarker):
     16        (AccessibilityTextMarker::isEqual):
     17        (AccessibilityTextMarker::platformTextMarker):
     18        (AccessibilityTextMarkerRange::AccessibilityTextMarkerRange):
     19        (AccessibilityTextMarkerRange::~AccessibilityTextMarkerRange):
     20        (AccessibilityTextMarkerRange::isEqual):
     21        (AccessibilityTextMarkerRange::platformTextMarkerRange):
     22        * DumpRenderTree/ios/AccessibilityUIElementIOS.mm:
     23        (AccessibilityUIElement::pathDescription):
     24        (AccessibilityUIElement::lineTextMarkerRangeForTextMarker):
     25        (AccessibilityUIElement::textMarkerRangeForElement):
     26        (AccessibilityUIElement::selectedTextMarkerRange):
     27        (AccessibilityUIElement::resetSelectedTextMarkerRange):
     28        (AccessibilityUIElement::textMarkerRangeLength):
     29        (AccessibilityUIElement::textMarkerRangeForMarkers):
     30        (AccessibilityUIElement::startTextMarkerForTextMarkerRange):
     31        (AccessibilityUIElement::endTextMarkerForTextMarkerRange):
     32        (AccessibilityUIElement::accessibilityElementForTextMarker):
     33        (AccessibilityUIElement::endTextMarkerForBounds):
     34        (AccessibilityUIElement::startTextMarkerForBounds):
     35        (AccessibilityUIElement::textMarkerForPoint):
     36        (AccessibilityUIElement::previousTextMarker):
     37        (AccessibilityUIElement::nextTextMarker):
     38        (AccessibilityUIElement::stringForTextMarkerRange):
     39        (AccessibilityUIElement::attributedStringForTextMarkerRangeContainsAttribute):
     40        (AccessibilityUIElement::indexForTextMarker):
     41        (AccessibilityUIElement::isTextMarkerValid):
     42        (AccessibilityUIElement::textMarkerForIndex):
     43        (AccessibilityUIElement::startTextMarker):
     44        (AccessibilityUIElement::endTextMarker):
     45        (AccessibilityUIElement::setSelectedVisibleTextRange):
     46        (AccessibilityUIElement::getLinkedUIElements):
     47        * DumpRenderTree/mac/AccessibilityTextMarkerMac.mm:
     48        (AccessibilityTextMarkerRange::platformTextMarkerRange):
     49        * DumpRenderTree/mac/AccessibilityUIElementMac.mm:
     50        (AccessibilityUIElement::removeSelection):
     51        (AccessibilityUIElement::lineTextMarkerRangeForTextMarker):
     52        (AccessibilityUIElement::setSelectedVisibleTextRange):
     53        (AccessibilityUIElement::supportedActions):
     54        * WebKitTestRunner/InjectedBundle/ios/AccessibilityUIElementIOS.mm:
     55        (WTR::AccessibilityUIElement::textMarkerRangeForElement):
     56        (WTR::AccessibilityUIElement::textMarkerRangeLength):
     57        (WTR::AccessibilityUIElement::previousTextMarker):
     58        (WTR::AccessibilityUIElement::nextTextMarker):
     59        (WTR::AccessibilityUIElement::stringForTextMarkerRange):
     60        (WTR::AccessibilityUIElement::textMarkerRangeForMarkers):
     61        (WTR::AccessibilityUIElement::startTextMarkerForTextMarkerRange):
     62        (WTR::AccessibilityUIElement::endTextMarkerForTextMarkerRange):
     63        (WTR::AccessibilityUIElement::endTextMarkerForBounds):
     64        (WTR::AccessibilityUIElement::accessibilityElementForTextMarker):
     65        (WTR::AccessibilityUIElement::attributedStringForTextMarkerRangeContainsAttribute):
     66
    1672016-01-20  Filip Pizlo  <fpizlo@apple.com>
    268

  • trunk/Tools/DumpRenderTree/AccessibilityTextMarker.h

    r164270 r195405  
    2929#include <JavaScriptCore/JSObjectRef.h>
    3030
    31 #if PLATFORM(MAC) && !PLATFORM(IOS)
     31#if PLATFORM(MAC) || PLATFORM(IOS)
    3232#define SUPPORTS_AX_TEXTMARKERS 1
    3333#else
    … …  
    5959private:
    6060    static JSClassRef getJSClass();
    61 #if SUPPORTS_AX_TEXTMARKERS
     61#if SUPPORTS_AX_TEXTMARKERS && PLATFORM(MAC)
    6262    RetainPtr<PlatformTextMarker> m_textMarker;
    6363#else
    … …  
    7979private:
    8080    static JSClassRef getJSClass();
    81 #if SUPPORTS_AX_TEXTMARKERS
     81#if SUPPORTS_AX_TEXTMARKERS && PLATFORM(MAC)
    8282    RetainPtr<PlatformTextMarkerRange> m_textMarkerRange;
    8383#else

  • trunk/Tools/DumpRenderTree/DumpRenderTree.xcodeproj/project.pbxproj

    r194115 r195405  
    9696                A8B91BFD0CF522B4008F91FF /* CheckedMalloc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A8B91BF70CF522B4008F91FF /* CheckedMalloc.cpp */; };
    9797                A8D79CEB0FC28B2C004AC8FE /* DumpRenderTreeFileDraggingSource.m in Sources */ = {isa = PBXBuildFile; fileRef = A8D79CE90FC28B2C004AC8FE /* DumpRenderTreeFileDraggingSource.m */; };
     98                A9BB7C5C1C505278002C525B /* AccessibilityTextMarkerIOS.mm in Sources */ = {isa = PBXBuildFile; fileRef = A9BB7C5B1C505278002C525B /* AccessibilityTextMarkerIOS.mm */; };
    9899                AA5A15EF16E15CD000F7C561 /* AccessibilityControllerIOS.mm in Sources */ = {isa = PBXBuildFile; fileRef = AA5A15ED16E15CD000F7C561 /* AccessibilityControllerIOS.mm */; };
    99100                AA5A15F016E15CD000F7C561 /* AccessibilityUIElementIOS.mm in Sources */ = {isa = PBXBuildFile; fileRef = AA5A15EE16E15CD000F7C561 /* AccessibilityUIElementIOS.mm */; };
    … …  
    310311                A8D79CE80FC28B2C004AC8FE /* DumpRenderTreeFileDraggingSource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DumpRenderTreeFileDraggingSource.h; sourceTree = "<group>"; };
    311312                A8D79CE90FC28B2C004AC8FE /* DumpRenderTreeFileDraggingSource.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = DumpRenderTreeFileDraggingSource.m; sourceTree = "<group>"; };
     313                A9BB7C5B1C505278002C525B /* AccessibilityTextMarkerIOS.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = AccessibilityTextMarkerIOS.mm; path = ios/AccessibilityTextMarkerIOS.mm; sourceTree = "<group>"; };
    312314                AA5A15ED16E15CD000F7C561 /* AccessibilityControllerIOS.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = AccessibilityControllerIOS.mm; path = ios/AccessibilityControllerIOS.mm; sourceTree = "<group>"; };
    313315                AA5A15EE16E15CD000F7C561 /* AccessibilityUIElementIOS.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = AccessibilityUIElementIOS.mm; path = ios/AccessibilityUIElementIOS.mm; sourceTree = "<group>"; };
    … …  
    500502                                29CFBA0F122736E600BC30C0 /* AccessibilityTextMarker.cpp */,
    501503                                29CFBA0E122736E600BC30C0 /* AccessibilityTextMarker.h */,
     504                                A9BB7C5B1C505278002C525B /* AccessibilityTextMarkerIOS.mm */,
    502505                                29CFBA2D12273A1000BC30C0 /* AccessibilityTextMarkerMac.mm */,
    503506                                BC0E24DF0E2D9451001B6BC2 /* AccessibilityUIElement.cpp */,
    … …  
    975978                                9830F31F15C81181005AB206 /* DumpRenderTreeCommon.cpp in Sources */,
    976979                                BCA18B7B0C9B08F100114369 /* DumpRenderTreeDraggingInfo.mm in Sources */,
     980                                A9BB7C5C1C505278002C525B /* AccessibilityTextMarkerIOS.mm in Sources */,
    977981                                A8D79CEB0FC28B2C004AC8FE /* DumpRenderTreeFileDraggingSource.m in Sources */,
    978982                                A8B91ADA0CF3B32F008F91FF /* DumpRenderTreePasteboard.m in Sources */,

  • trunk/Tools/DumpRenderTree/ios/AccessibilityTextMarkerIOS.mm

    r195398 r195405  
    11/*
    2  * Copyright (C) 2010 Apple Inc. All Rights Reserved.
     2 * Copyright (C) 2016 Apple Inc. All Rights Reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2525
    2626#import "config.h"
     27#import "AccessibilityTextMarker.h"
    2728
    28 #import "AccessibilityTextMarker.h"
    2929#import "DumpRenderTree.h"
    3030
    31 #if SUPPORTS_AX_TEXTMARKERS
     31#if SUPPORTS_AX_TEXTMARKERS && PLATFORM(IOS)
    3232
    3333// MARK: AccessibilityTextMarker
    … …  
    5454PlatformTextMarker AccessibilityTextMarker::platformTextMarker() const
    5555{
    56     return m_textMarker.get();
     56    return m_textMarker;
    5757}
    5858
    … …  
    8080PlatformTextMarkerRange AccessibilityTextMarkerRange::platformTextMarkerRange() const
    8181{
    82     return m_textMarkerRange.get();
     82    return m_textMarkerRange;
    8383}
    8484
    85 #endif // SUPPORTS_AX_TEXTMARKERS
     85#endif // SUPPORTS_AX_TEXTMARKERS && PLATFORM(IOS)

  • trunk/Tools/DumpRenderTree/ios/AccessibilityUIElementIOS.mm

    r194054 r195405  
    9595- (UIAccessibilityTraits)_axContainedByFieldsetTrait;
    9696- (id)_accessibilityFieldsetAncestor;
     97
     98// TextMarker related
     99- (NSArray *)textMarkerRange;
     100- (NSInteger)lengthForTextMarkers:(NSArray *)textMarkers;
     101- (NSString *)stringForTextMarkers:(NSArray *)markers;
     102- (id)startOrEndTextMarkerForTextMarkers:(NSArray*)textMarkers isStart:(BOOL)isStart;
     103- (NSArray *)textMarkerRangeForMarkers:(NSArray *)textMarkers;
     104- (id)nextMarkerForMarker:(id)marker;
     105- (id)previousMarkerForMarker:(id)marker;
     106- (id)accessibilityObjectForTextMarker:(id)marker;
    97107@end
    98108
    … …  
    412422}
    413423
     424#if SUPPORTS_AX_TEXTMARKERS && PLATFORM(IOS)
     425
     426// Text markers
     427
     428AccessibilityTextMarkerRange AccessibilityUIElement::lineTextMarkerRangeForTextMarker(AccessibilityTextMarker*)
     429{
     430    return nullptr;
     431}
     432
     433AccessibilityTextMarkerRange AccessibilityUIElement::textMarkerRangeForElement(AccessibilityUIElement* element)
     434{
     435    id textMarkerRange = [element->platformUIElement() textMarkerRange];
     436    return AccessibilityTextMarkerRange(textMarkerRange);
     437}
     438
     439AccessibilityTextMarkerRange AccessibilityUIElement::selectedTextMarkerRange()
     440{
     441    return nullptr;
     442}
     443
     444void AccessibilityUIElement::resetSelectedTextMarkerRange()
     445{
     446}
     447
     448int AccessibilityUIElement::textMarkerRangeLength(AccessibilityTextMarkerRange* range)
     449{
     450    id textMarkers = (id)range->platformTextMarkerRange();
     451    return [m_element lengthForTextMarkers:textMarkers];
     452}
     453
     454AccessibilityTextMarkerRange AccessibilityUIElement::textMarkerRangeForMarkers(AccessibilityTextMarker* startMarker, AccessibilityTextMarker* endMarker)
     455{
     456    NSArray *textMarkers = [NSArray arrayWithObjects:(id)startMarker->platformTextMarker(), (id)endMarker->platformTextMarker(), nil];
     457    id textMarkerRange = [m_element textMarkerRangeForMarkers:textMarkers];
     458    return AccessibilityTextMarkerRange(textMarkerRange);
     459}
     460
     461AccessibilityTextMarker AccessibilityUIElement::startTextMarkerForTextMarkerRange(AccessibilityTextMarkerRange* range)
     462{
     463    id textMarkers = (id)range->platformTextMarkerRange();
     464    id textMarker = [m_element startOrEndTextMarkerForTextMarkers:textMarkers isStart:YES];
     465    return AccessibilityTextMarker(textMarker);
     466}
     467
     468AccessibilityTextMarker AccessibilityUIElement::endTextMarkerForTextMarkerRange(AccessibilityTextMarkerRange* range)
     469{
     470    id textMarkers = (id)range->platformTextMarkerRange();
     471    id textMarker = [m_element startOrEndTextMarkerForTextMarkers:textMarkers isStart:NO];
     472    return AccessibilityTextMarker(textMarker);
     473}
     474
     475AccessibilityUIElement AccessibilityUIElement::accessibilityElementForTextMarker(AccessibilityTextMarker* marker)
     476{
     477    id obj = [m_element accessibilityObjectForTextMarker:(id)marker->platformTextMarker()];
     478    if (obj)
     479        return AccessibilityUIElement(obj);
     480    return nullptr;
     481}
     482
     483AccessibilityTextMarker AccessibilityUIElement::endTextMarkerForBounds(int x, int y, int width, int height)
     484{
     485    return nullptr;
     486}
     487
     488AccessibilityTextMarker AccessibilityUIElement::startTextMarkerForBounds(int x, int y, int width, int height)
     489{
     490    return nullptr;
     491}
     492
     493AccessibilityTextMarker AccessibilityUIElement::textMarkerForPoint(int x, int y)
     494{
     495    return nullptr;
     496}
     497
     498AccessibilityTextMarker AccessibilityUIElement::previousTextMarker(AccessibilityTextMarker* textMarker)
     499{
     500    id previousMarker = [m_element previousMarkerForMarker:(id)textMarker->platformTextMarker()];
     501    return AccessibilityTextMarker(previousMarker);
     502}
     503
     504AccessibilityTextMarker AccessibilityUIElement::nextTextMarker(AccessibilityTextMarker* textMarker)
     505{
     506    id nextMarker = [m_element nextMarkerForMarker:(id)textMarker->platformTextMarker()];
     507    return AccessibilityTextMarker(nextMarker);
     508}
     509
     510JSStringRef AccessibilityUIElement::stringForTextMarkerRange(AccessibilityTextMarkerRange* markerRange)
     511{
     512    id textMarkers = (id)markerRange->platformTextMarkerRange();
     513    if (!textMarkers || ![textMarkers isKindOfClass:[NSArray class]])
     514        return JSStringCreateWithCharacters(0, 0);
     515    return [[m_element stringForTextMarkers:textMarkers] createJSStringRef];
     516}
     517
     518bool AccessibilityUIElement::attributedStringForTextMarkerRangeContainsAttribute(JSStringRef, AccessibilityTextMarkerRange*)
     519{
     520    return false;
     521}
     522
     523int AccessibilityUIElement::indexForTextMarker(AccessibilityTextMarker*)
     524{
     525    return -1;
     526}
     527
     528bool AccessibilityUIElement::isTextMarkerValid(AccessibilityTextMarker*)
     529{
     530    return false;
     531}
     532
     533AccessibilityTextMarker AccessibilityUIElement::textMarkerForIndex(int)
     534{
     535    return nullptr;
     536}
     537
     538AccessibilityTextMarker AccessibilityUIElement::startTextMarker()
     539{
     540    return nullptr;
     541}
     542
     543AccessibilityTextMarker AccessibilityUIElement::endTextMarker()
     544{
     545    return nullptr;
     546}
     547
     548bool AccessibilityUIElement::setSelectedVisibleTextRange(AccessibilityTextMarkerRange*)
     549{
     550    return false;
     551}
     552
     553#endif // SUPPORTS_AX_TEXTMARKERS && PLATFORM(IOS)
     554
    414555#pragma mark Unused
    415556

  • trunk/Tools/DumpRenderTree/mac/AccessibilityTextMarkerMac.mm

    r162817 r195405  
    2929#import "DumpRenderTree.h"
    3030
    31 #if SUPPORTS_AX_TEXTMARKERS
     31#if SUPPORTS_AX_TEXTMARKERS && PLATFORM(MAC)
    3232
    3333// MARK: AccessibilityTextMarker
    … …  
    8383}
    8484
    85 #endif // SUPPORTS_AX_TEXTMARKERS
     85#endif // SUPPORTS_AX_TEXTMARKERS && PLATFORM(MAC)

  • trunk/Tools/DumpRenderTree/mac/AccessibilityUIElementMac.mm

    r194364 r195405  
    16131613}
    16141614
    1615 #if SUPPORTS_AX_TEXTMARKERS
     1615#if SUPPORTS_AX_TEXTMARKERS && PLATFORM(MAC)
    16161616
    16171617// Text markers
    … …  
    18471847}
    18481848
    1849 #endif // SUPPORTS_AX_TEXTMARKERS
     1849#endif // SUPPORTS_AX_TEXTMARKERS && PLATFORM(MAC)
    18501850
    18511851JSStringRef AccessibilityUIElement::supportedActions()

  • trunk/Tools/WebKitTestRunner/InjectedBundle/ios/AccessibilityUIElementIOS.mm

    r194054 r195405  
    7272- (UIAccessibilityTraits)_axContainedByFieldsetTrait;
    7373- (id)_accessibilityFieldsetAncestor;
     74
     75// TextMarker related
     76- (NSArray *)textMarkerRange;
     77- (NSInteger)lengthForTextMarkers:(NSArray *)textMarkers;
     78- (NSString *)stringForTextMarkers:(NSArray *)markers;
     79- (id)startOrEndTextMarkerForTextMarkers:(NSArray*)textMarkers isStart:(BOOL)isStart;
     80- (NSArray *)textMarkerRangeForMarkers:(NSArray *)textMarkers;
     81- (id)nextMarkerForMarker:(id)marker;
     82- (id)previousMarkerForMarker:(id)marker;
     83- (id)accessibilityObjectForTextMarker:(id)marker;
    7484@end
    7585
    … …  
    983993PassRefPtr<AccessibilityTextMarkerRange> AccessibilityUIElement::textMarkerRangeForElement(AccessibilityUIElement* element)
    984994{
    985     return 0;
     995    id textMarkerRange = [element->platformUIElement() textMarkerRange];
     996    return AccessibilityTextMarkerRange::create(textMarkerRange);
    986997}
    987998
    988999int AccessibilityUIElement::textMarkerRangeLength(AccessibilityTextMarkerRange* range)
    9891000{
    990     return 0;
     1001    id textMarkers = (id)range->platformTextMarkerRange();   
     1002    return [m_element lengthForTextMarkers:textMarkers];
    9911003}
    9921004
    9931005PassRefPtr<AccessibilityTextMarker> AccessibilityUIElement::previousTextMarker(AccessibilityTextMarker* textMarker)
    9941006{
    995     return 0;
     1007    id previousMarker = [m_element previousMarkerForMarker:(id)textMarker->platformTextMarker()];
     1008    return AccessibilityTextMarker::create(previousMarker);
    9961009}
    9971010
    9981011PassRefPtr<AccessibilityTextMarker> AccessibilityUIElement::nextTextMarker(AccessibilityTextMarker* textMarker)
    9991012{
    1000     return 0;
     1013    id nextMarker = [m_element nextMarkerForMarker:(id)textMarker->platformTextMarker()];
     1014    return AccessibilityTextMarker::create(nextMarker);
    10011015}
    10021016
    10031017JSRetainPtr<JSStringRef> AccessibilityUIElement::stringForTextMarkerRange(AccessibilityTextMarkerRange* markerRange)
    10041018{
    1005     return 0;
     1019    id textMarkers = (id)markerRange->platformTextMarkerRange();
     1020    if (!textMarkers || ![textMarkers isKindOfClass:[NSArray class]])
     1021        return JSStringCreateWithCharacters(0, 0);
     1022    return [[m_element stringForTextMarkers:textMarkers] createJSStringRef];
    10061023}
    10071024
    10081025PassRefPtr<AccessibilityTextMarkerRange> AccessibilityUIElement::textMarkerRangeForMarkers(AccessibilityTextMarker* startMarker, AccessibilityTextMarker* endMarker)
    10091026{
    1010     return 0;
     1027    NSArray *textMarkers = [NSArray arrayWithObjects:(id)startMarker->platformTextMarker(), (id)endMarker->platformTextMarker(), nil];
     1028    id textMarkerRange = [m_element textMarkerRangeForMarkers:textMarkers];
     1029    return AccessibilityTextMarkerRange::create(textMarkerRange);
    10111030}
    10121031
    10131032PassRefPtr<AccessibilityTextMarker> AccessibilityUIElement::startTextMarkerForTextMarkerRange(AccessibilityTextMarkerRange* range)
    10141033{
    1015     return 0;
     1034    id textMarkers = (id)range->platformTextMarkerRange();
     1035    id textMarker = [m_element startOrEndTextMarkerForTextMarkers:textMarkers isStart:YES];
     1036    return AccessibilityTextMarker::create(textMarker);
    10161037}
    10171038
    10181039PassRefPtr<AccessibilityTextMarker> AccessibilityUIElement::endTextMarkerForTextMarkerRange(AccessibilityTextMarkerRange* range)
    10191040{
    1020     return 0;
     1041    id textMarkers = (id)range->platformTextMarkerRange();
     1042    id textMarker = [m_element startOrEndTextMarkerForTextMarkers:textMarkers isStart:NO];
     1043    return AccessibilityTextMarker::create(textMarker);
    10211044}
    10221045
    … …  
    10381061PassRefPtr<AccessibilityUIElement> AccessibilityUIElement::accessibilityElementForTextMarker(AccessibilityTextMarker* marker)
    10391062{
    1040     return 0;
     1063    id obj = [m_element accessibilityObjectForTextMarker:(id)marker->platformTextMarker()];
     1064    if (obj)
     1065        return AccessibilityUIElement::create(obj);
     1066    return nullptr;
    10411067}
    10421068
Note: See TracChangeset for help on using the changeset viewer.