| /* |
| * Copyright (C) 2008-2009, 2011, 2017 Apple Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. Neither the name of Apple Inc. ("Apple") nor the names of |
| * its contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY |
| * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
| * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY |
| * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
| * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "config.h" |
| #include "AccessibilityObject.h" |
| |
| #include "AXObjectCache.h" |
| #include "AccessibilityRenderObject.h" |
| #include "AccessibilityScrollView.h" |
| #include "AccessibilityTable.h" |
| #include "AccessibleSetValueEvent.h" |
| #include "DOMTokenList.h" |
| #include "Editing.h" |
| #include "Editor.h" |
| #include "ElementIterator.h" |
| #include "Event.h" |
| #include "EventDispatcher.h" |
| #include "EventHandler.h" |
| #include "FloatRect.h" |
| #include "FocusController.h" |
| #include "Frame.h" |
| #include "FrameLoader.h" |
| #include "FrameSelection.h" |
| #include "HTMLDetailsElement.h" |
| #include "HTMLFormControlElement.h" |
| #include "HTMLInputElement.h" |
| #include "HTMLMediaElement.h" |
| #include "HTMLNames.h" |
| #include "HTMLParserIdioms.h" |
| #include "HitTestResult.h" |
| #include "LocalizedStrings.h" |
| #include "MathMLNames.h" |
| #include "NodeList.h" |
| #include "NodeTraversal.h" |
| #include "Page.h" |
| #include "RenderImage.h" |
| #include "RenderLayer.h" |
| #include "RenderListItem.h" |
| #include "RenderListMarker.h" |
| #include "RenderMenuList.h" |
| #include "RenderText.h" |
| #include "RenderTextControl.h" |
| #include "RenderTheme.h" |
| #include "RenderView.h" |
| #include "RenderWidget.h" |
| #include "RenderedPosition.h" |
| #include "RuntimeEnabledFeatures.h" |
| #include "Settings.h" |
| #include "TextCheckerClient.h" |
| #include "TextCheckingHelper.h" |
| #include "TextIterator.h" |
| #include "UserGestureIndicator.h" |
| #include "VisibleUnits.h" |
| #include <wtf/NeverDestroyed.h> |
| #include <wtf/StdLibExtras.h> |
| #include <wtf/text/StringBuilder.h> |
| #include <wtf/text/StringView.h> |
| #include <wtf/text/WTFString.h> |
| #include <wtf/unicode/CharacterNames.h> |
| |
| namespace WebCore { |
| |
| using namespace HTMLNames; |
| |
| AccessibilityObject::~AccessibilityObject() |
| { |
| ASSERT(isDetached()); |
| } |
| |
| void AccessibilityObject::detach(AccessibilityDetachmentType detachmentType, AXObjectCache* cache) |
| { |
| // Menu close events need to notify the platform. No element is used in the notification because it's a destruction event. |
| if (detachmentType == AccessibilityDetachmentType::ElementDestroyed && roleValue() == AccessibilityRole::Menu && cache) |
| cache->postNotification(nullptr, &cache->document(), AXObjectCache::AXMenuClosed); |
| |
| // Clear any children and call detachFromParent on them so that |
| // no children are left with dangling pointers to their parent. |
| clearChildren(); |
| |
| #if HAVE(ACCESSIBILITY) |
| setWrapper(nullptr); |
| #endif |
| } |
| |
| bool AccessibilityObject::isDetached() const |
| { |
| #if HAVE(ACCESSIBILITY) |
| return !wrapper(); |
| #else |
| return true; |
| #endif |
| } |
| |
| bool AccessibilityObject::isAccessibilityObjectSearchMatchAtIndex(AccessibilityObject* axObject, AccessibilitySearchCriteria* criteria, size_t index) |
| { |
| switch (criteria->searchKeys[index]) { |
| // The AccessibilitySearchKey::AnyType matches any non-null AccessibilityObject. |
| case AccessibilitySearchKey::AnyType: |
| return true; |
| |
| case AccessibilitySearchKey::Article: |
| return axObject->roleValue() == AccessibilityRole::DocumentArticle; |
| |
| case AccessibilitySearchKey::BlockquoteSameLevel: |
| return criteria->startObject |
| && axObject->isBlockquote() |
| && axObject->blockquoteLevel() == criteria->startObject->blockquoteLevel(); |
| |
| case AccessibilitySearchKey::Blockquote: |
| return axObject->isBlockquote(); |
| |
| case AccessibilitySearchKey::BoldFont: |
| return axObject->hasBoldFont(); |
| |
| case AccessibilitySearchKey::Button: |
| return axObject->isButton(); |
| |
| case AccessibilitySearchKey::CheckBox: |
| return axObject->isCheckbox(); |
| |
| case AccessibilitySearchKey::Control: |
| return axObject->isControl(); |
| |
| case AccessibilitySearchKey::DifferentType: |
| return criteria->startObject |
| && axObject->roleValue() != criteria->startObject->roleValue(); |
| |
| case AccessibilitySearchKey::FontChange: |
| return criteria->startObject |
| && !axObject->hasSameFont(criteria->startObject->renderer()); |
| |
| case AccessibilitySearchKey::FontColorChange: |
| return criteria->startObject |
| && !axObject->hasSameFontColor(criteria->startObject->renderer()); |
| |
| case AccessibilitySearchKey::Frame: |
| return axObject->isWebArea(); |
| |
| case AccessibilitySearchKey::Graphic: |
| return axObject->isImage(); |
| |
| case AccessibilitySearchKey::HeadingLevel1: |
| return axObject->headingLevel() == 1; |
| |
| case AccessibilitySearchKey::HeadingLevel2: |
| return axObject->headingLevel() == 2; |
| |
| case AccessibilitySearchKey::HeadingLevel3: |
| return axObject->headingLevel() == 3; |
| |
| case AccessibilitySearchKey::HeadingLevel4: |
| return axObject->headingLevel() == 4; |
| |
| case AccessibilitySearchKey::HeadingLevel5: |
| return axObject->headingLevel() == 5; |
| |
| case AccessibilitySearchKey::HeadingLevel6: |
| return axObject->headingLevel() == 6; |
| |
| case AccessibilitySearchKey::HeadingSameLevel: |
| return criteria->startObject |
| && axObject->isHeading() |
| && axObject->headingLevel() == criteria->startObject->headingLevel(); |
| |
| case AccessibilitySearchKey::Heading: |
| return axObject->isHeading(); |
| |
| case AccessibilitySearchKey::Highlighted: |
| return axObject->hasHighlighting(); |
| |
| case AccessibilitySearchKey::ItalicFont: |
| return axObject->hasItalicFont(); |
| |
| case AccessibilitySearchKey::Landmark: |
| return axObject->isLandmark(); |
| |
| case AccessibilitySearchKey::Link: { |
| bool isLink = axObject->isLink(); |
| #if PLATFORM(IOS) |
| if (!isLink) |
| isLink = axObject->isDescendantOfRole(AccessibilityRole::WebCoreLink); |
| #endif |
| return isLink; |
| } |
| |
| case AccessibilitySearchKey::List: |
| return axObject->isList(); |
| |
| case AccessibilitySearchKey::LiveRegion: |
| return axObject->supportsLiveRegion(); |
| |
| case AccessibilitySearchKey::MisspelledWord: |
| return axObject->hasMisspelling(); |
| |
| case AccessibilitySearchKey::Outline: |
| return axObject->isTree(); |
| |
| case AccessibilitySearchKey::PlainText: |
| return axObject->hasPlainText(); |
| |
| case AccessibilitySearchKey::RadioGroup: |
| return axObject->isRadioGroup(); |
| |
| case AccessibilitySearchKey::SameType: |
| return criteria->startObject |
| && axObject->roleValue() == criteria->startObject->roleValue(); |
| |
| case AccessibilitySearchKey::StaticText: |
| return axObject->isStaticText(); |
| |
| case AccessibilitySearchKey::StyleChange: |
| return criteria->startObject |
| && !axObject->hasSameStyle(criteria->startObject->renderer()); |
| |
| case AccessibilitySearchKey::TableSameLevel: |
| return criteria->startObject |
| && is<AccessibilityTable>(*axObject) && downcast<AccessibilityTable>(*axObject).isExposableThroughAccessibility() |
| && downcast<AccessibilityTable>(*axObject).tableLevel() == criteria->startObject->tableLevel(); |
| |
| case AccessibilitySearchKey::Table: |
| return is<AccessibilityTable>(*axObject) && downcast<AccessibilityTable>(*axObject).isExposableThroughAccessibility(); |
| |
| case AccessibilitySearchKey::TextField: |
| return axObject->isTextControl(); |
| |
| case AccessibilitySearchKey::Underline: |
| return axObject->hasUnderline(); |
| |
| case AccessibilitySearchKey::UnvisitedLink: |
| return axObject->isUnvisited(); |
| |
| case AccessibilitySearchKey::VisitedLink: |
| return axObject->isVisited(); |
| |
| default: |
| return false; |
| } |
| } |
| |
| bool AccessibilityObject::isAccessibilityObjectSearchMatch(AccessibilityObject* axObject, AccessibilitySearchCriteria* criteria) |
| { |
| if (!axObject || !criteria) |
| return false; |
| |
| size_t length = criteria->searchKeys.size(); |
| for (size_t i = 0; i < length; ++i) { |
| if (isAccessibilityObjectSearchMatchAtIndex(axObject, criteria, i)) { |
| if (criteria->visibleOnly && !axObject->isOnscreen()) |
| return false; |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| bool AccessibilityObject::isAccessibilityTextSearchMatch(AccessibilityObject* axObject, AccessibilitySearchCriteria* criteria) |
| { |
| if (!axObject || !criteria) |
| return false; |
| |
| return axObject->accessibilityObjectContainsText(&criteria->searchText); |
| } |
| |
| bool AccessibilityObject::accessibilityObjectContainsText(String* text) const |
| { |
| // If text is null or empty we return true. |
| return !text |
| || text->isEmpty() |
| || findPlainText(title(), *text, CaseInsensitive) |
| || findPlainText(accessibilityDescription(), *text, CaseInsensitive) |
| || findPlainText(stringValue(), *text, CaseInsensitive); |
| } |
| |
| // ARIA marks elements as having their accessible name derive from either their contents, or their author provide name. |
| bool AccessibilityObject::accessibleNameDerivesFromContent() const |
| { |
| // First check for objects specifically identified by ARIA. |
| switch (ariaRoleAttribute()) { |
| case AccessibilityRole::ApplicationAlert: |
| case AccessibilityRole::ApplicationAlertDialog: |
| case AccessibilityRole::ApplicationDialog: |
| case AccessibilityRole::ApplicationGroup: |
| case AccessibilityRole::ApplicationLog: |
| case AccessibilityRole::ApplicationMarquee: |
| case AccessibilityRole::ApplicationStatus: |
| case AccessibilityRole::ApplicationTimer: |
| case AccessibilityRole::ComboBox: |
| case AccessibilityRole::Definition: |
| case AccessibilityRole::Document: |
| case AccessibilityRole::DocumentArticle: |
| case AccessibilityRole::DocumentMath: |
| case AccessibilityRole::DocumentNote: |
| case AccessibilityRole::LandmarkRegion: |
| case AccessibilityRole::LandmarkDocRegion: |
| case AccessibilityRole::Form: |
| case AccessibilityRole::Grid: |
| case AccessibilityRole::Group: |
| case AccessibilityRole::Image: |
| case AccessibilityRole::List: |
| case AccessibilityRole::ListBox: |
| case AccessibilityRole::LandmarkBanner: |
| case AccessibilityRole::LandmarkComplementary: |
| case AccessibilityRole::LandmarkContentInfo: |
| case AccessibilityRole::LandmarkNavigation: |
| case AccessibilityRole::LandmarkMain: |
| case AccessibilityRole::LandmarkSearch: |
| case AccessibilityRole::Menu: |
| case AccessibilityRole::MenuBar: |
| case AccessibilityRole::ProgressIndicator: |
| case AccessibilityRole::RadioGroup: |
| case AccessibilityRole::ScrollBar: |
| case AccessibilityRole::Slider: |
| case AccessibilityRole::SpinButton: |
| case AccessibilityRole::Splitter: |
| case AccessibilityRole::Table: |
| case AccessibilityRole::TabList: |
| case AccessibilityRole::TabPanel: |
| case AccessibilityRole::TextArea: |
| case AccessibilityRole::TextField: |
| case AccessibilityRole::Toolbar: |
| case AccessibilityRole::TreeGrid: |
| case AccessibilityRole::Tree: |
| case AccessibilityRole::WebApplication: |
| return false; |
| default: |
| break; |
| } |
| |
| // Now check for generically derived elements now that we know the element does not match a specific ARIA role. |
| switch (roleValue()) { |
| case AccessibilityRole::Slider: |
| return false; |
| default: |
| break; |
| } |
| |
| return true; |
| } |
| |
| String AccessibilityObject::computedLabel() |
| { |
| // This method is being called by WebKit inspector, which may happen at any time, so we need to update our backing store now. |
| // Also hold onto this object in case updateBackingStore deletes this node. |
| RefPtr<AccessibilityObject> protectedThis(this); |
| updateBackingStore(); |
| Vector<AccessibilityText> text; |
| accessibilityText(text); |
| if (text.size()) |
| return text[0].text; |
| return String(); |
| } |
| |
| bool AccessibilityObject::isBlockquote() const |
| { |
| return roleValue() == AccessibilityRole::Blockquote; |
| } |
| |
| bool AccessibilityObject::isTextControl() const |
| { |
| switch (roleValue()) { |
| case AccessibilityRole::ComboBox: |
| case AccessibilityRole::SearchField: |
| case AccessibilityRole::TextArea: |
| case AccessibilityRole::TextField: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool AccessibilityObject::isARIATextControl() const |
| { |
| return ariaRoleAttribute() == AccessibilityRole::TextArea || ariaRoleAttribute() == AccessibilityRole::TextField || ariaRoleAttribute() == AccessibilityRole::SearchField; |
| } |
| |
| bool AccessibilityObject::isNonNativeTextControl() const |
| { |
| return (isARIATextControl() || hasContentEditableAttributeSet()) && !isNativeTextControl(); |
| } |
| |
| bool AccessibilityObject::isLandmark() const |
| { |
| AccessibilityRole role = roleValue(); |
| |
| return role == AccessibilityRole::LandmarkBanner |
| || role == AccessibilityRole::LandmarkComplementary |
| || role == AccessibilityRole::LandmarkContentInfo |
| || role == AccessibilityRole::LandmarkDocRegion |
| || role == AccessibilityRole::LandmarkMain |
| || role == AccessibilityRole::LandmarkNavigation |
| || role == AccessibilityRole::LandmarkRegion |
| || role == AccessibilityRole::LandmarkSearch; |
| } |
| |
| bool AccessibilityObject::hasMisspelling() const |
| { |
| if (!node()) |
| return false; |
| |
| Frame* frame = node()->document().frame(); |
| if (!frame) |
| return false; |
| |
| Editor& editor = frame->editor(); |
| |
| TextCheckerClient* textChecker = editor.textChecker(); |
| if (!textChecker) |
| return false; |
| |
| bool isMisspelled = false; |
| |
| if (unifiedTextCheckerEnabled(frame)) { |
| Vector<TextCheckingResult> results; |
| checkTextOfParagraph(*textChecker, stringValue(), TextCheckingTypeSpelling, results, frame->selection().selection()); |
| if (!results.isEmpty()) |
| isMisspelled = true; |
| return isMisspelled; |
| } |
| |
| int misspellingLength = 0; |
| int misspellingLocation = -1; |
| textChecker->checkSpellingOfString(stringValue(), &misspellingLocation, &misspellingLength); |
| if (misspellingLength || misspellingLocation != -1) |
| isMisspelled = true; |
| |
| return isMisspelled; |
| } |
| |
| unsigned AccessibilityObject::blockquoteLevel() const |
| { |
| unsigned level = 0; |
| for (Node* elementNode = node(); elementNode; elementNode = elementNode->parentNode()) { |
| if (elementNode->hasTagName(blockquoteTag)) |
| ++level; |
| } |
| |
| return level; |
| } |
| |
| AccessibilityObject* AccessibilityObject::parentObjectUnignored() const |
| { |
| return const_cast<AccessibilityObject*>(AccessibilityObject::matchedParent(*this, false, [] (const AccessibilityObject& object) { |
| return !object.accessibilityIsIgnored(); |
| })); |
| } |
| |
| AccessibilityObject* AccessibilityObject::previousSiblingUnignored(int limit) const |
| { |
| AccessibilityObject* previous; |
| ASSERT(limit >= 0); |
| for (previous = previousSibling(); previous && previous->accessibilityIsIgnored(); previous = previous->previousSibling()) { |
| limit--; |
| if (limit <= 0) |
| break; |
| } |
| return previous; |
| } |
| |
| AccessibilityObject* AccessibilityObject::nextSiblingUnignored(int limit) const |
| { |
| AccessibilityObject* next; |
| ASSERT(limit >= 0); |
| for (next = nextSibling(); next && next->accessibilityIsIgnored(); next = next->nextSibling()) { |
| limit--; |
| if (limit <= 0) |
| break; |
| } |
| return next; |
| } |
| |
| AccessibilityObject* AccessibilityObject::firstAccessibleObjectFromNode(const Node* node) |
| { |
| if (!node) |
| return nullptr; |
| |
| AXObjectCache* cache = node->document().axObjectCache(); |
| if (!cache) |
| return nullptr; |
| |
| AccessibilityObject* accessibleObject = cache->getOrCreate(node->renderer()); |
| while (accessibleObject && accessibleObject->accessibilityIsIgnored()) { |
| node = NodeTraversal::next(*node); |
| |
| while (node && !node->renderer()) |
| node = NodeTraversal::nextSkippingChildren(*node); |
| |
| if (!node) |
| return nullptr; |
| |
| accessibleObject = cache->getOrCreate(node->renderer()); |
| } |
| |
| return accessibleObject; |
| } |
| |
| bool AccessibilityObject::isDescendantOfRole(AccessibilityRole role) const |
| { |
| return AccessibilityObject::matchedParent(*this, false, [&role] (const AccessibilityObject& object) { |
| return object.roleValue() == role; |
| }) != nullptr; |
| } |
| |
| static void appendAccessibilityObject(AccessibilityObject* object, AccessibilityObject::AccessibilityChildrenVector& results) |
| { |
| // Find the next descendant of this attachment object so search can continue through frames. |
| if (object->isAttachment()) { |
| Widget* widget = object->widgetForAttachmentView(); |
| if (!is<FrameView>(widget)) |
| return; |
| |
| Document* document = downcast<FrameView>(*widget).frame().document(); |
| if (!document || !document->hasLivingRenderTree()) |
| return; |
| |
| object = object->axObjectCache()->getOrCreate(document); |
| } |
| |
| if (object) |
| results.append(object); |
| } |
| |
| void AccessibilityObject::insertChild(AccessibilityObject* child, unsigned index) |
| { |
| if (!child) |
| return; |
| |
| // If the parent is asking for this child's children, then either it's the first time (and clearing is a no-op), |
| // or its visibility has changed. In the latter case, this child may have a stale child cached. |
| // This can prevent aria-hidden changes from working correctly. Hence, whenever a parent is getting children, ensure data is not stale. |
| // Only clear the child's children when we know it's in the updating chain in order to avoid unnecessary work. |
| if (child->needsToUpdateChildren() || m_subtreeDirty) { |
| child->clearChildren(); |
| // Pass m_subtreeDirty flag down to the child so that children cache gets reset properly. |
| if (m_subtreeDirty) |
| child->setNeedsToUpdateSubtree(); |
| } else { |
| // For some reason the grand children might be detached so that we need to regenerate the |
| // children list of this child. |
| for (const auto& grandChild : child->children(false)) { |
| if (grandChild->isDetachedFromParent()) { |
| child->clearChildren(); |
| break; |
| } |
| } |
| } |
| |
| setIsIgnoredFromParentDataForChild(child); |
| if (child->accessibilityIsIgnored()) { |
| const auto& children = child->children(); |
| size_t length = children.size(); |
| for (size_t i = 0; i < length; ++i) |
| m_children.insert(index + i, children[i]); |
| } else { |
| ASSERT(child->parentObject() == this); |
| m_children.insert(index, child); |
| } |
| |
| // Reset the child's m_isIgnoredFromParentData since we are done adding that child and its children. |
| child->clearIsIgnoredFromParentData(); |
| } |
| |
| void AccessibilityObject::addChild(AccessibilityObject* child) |
| { |
| insertChild(child, m_children.size()); |
| } |
| |
| static void appendChildrenToArray(AccessibilityObject* object, bool isForward, AccessibilityObject* startObject, AccessibilityObject::AccessibilityChildrenVector& results) |
| { |
| // A table's children includes elements whose own children are also the table's children (due to the way the Mac exposes tables). |
| // The rows from the table should be queried, since those are direct descendants of the table, and they contain content. |
| const auto& searchChildren = is<AccessibilityTable>(*object) && downcast<AccessibilityTable>(*object).isExposableThroughAccessibility() ? downcast<AccessibilityTable>(*object).rows() : object->children(); |
| |
| size_t childrenSize = searchChildren.size(); |
| |
| size_t startIndex = isForward ? childrenSize : 0; |
| size_t endIndex = isForward ? 0 : childrenSize; |
| |
| // If the startObject is ignored, we should use an accessible sibling as a start element instead. |
| if (startObject && startObject->accessibilityIsIgnored() && startObject->isDescendantOfObject(object)) { |
| AccessibilityObject* parentObject = startObject->parentObject(); |
| // Go up the parent chain to find the highest ancestor that's also being ignored. |
| while (parentObject && parentObject->accessibilityIsIgnored()) { |
| if (parentObject == object) |
| break; |
| startObject = parentObject; |
| parentObject = parentObject->parentObject(); |
| } |
| // Get the un-ignored sibling based on the search direction, and update the searchPosition. |
| while (startObject && startObject->accessibilityIsIgnored()) |
| startObject = isForward ? startObject->previousSibling() : startObject->nextSibling(); |
| } |
| |
| size_t searchPosition = startObject ? searchChildren.find(startObject) : WTF::notFound; |
| |
| if (searchPosition != WTF::notFound) { |
| if (isForward) |
| endIndex = searchPosition + 1; |
| else |
| endIndex = searchPosition; |
| } |
| |
| // This is broken into two statements so that it's easier read. |
| if (isForward) { |
| for (size_t i = startIndex; i > endIndex; i--) |
| appendAccessibilityObject(searchChildren.at(i - 1).get(), results); |
| } else { |
| for (size_t i = startIndex; i < endIndex; i++) |
| appendAccessibilityObject(searchChildren.at(i).get(), results); |
| } |
| } |
| |
| // Returns true if the number of results is now >= the number of results desired. |
| bool AccessibilityObject::objectMatchesSearchCriteriaWithResultLimit(AccessibilityObject* object, AccessibilitySearchCriteria* criteria, AccessibilityChildrenVector& results) |
| { |
| if (isAccessibilityObjectSearchMatch(object, criteria) && isAccessibilityTextSearchMatch(object, criteria)) { |
| results.append(object); |
| |
| // Enough results were found to stop searching. |
| if (results.size() >= criteria->resultsLimit) |
| return true; |
| } |
| |
| return false; |
| } |
| |
| void AccessibilityObject::findMatchingObjects(AccessibilitySearchCriteria* criteria, AccessibilityChildrenVector& results) |
| { |
| ASSERT(criteria); |
| |
| if (!criteria) |
| return; |
| |
| if (AXObjectCache* cache = axObjectCache()) |
| cache->startCachingComputedObjectAttributesUntilTreeMutates(); |
| |
| // This search mechanism only searches the elements before/after the starting object. |
| // It does this by stepping up the parent chain and at each level doing a DFS. |
| |
| // If there's no start object, it means we want to search everything. |
| AccessibilityObject* startObject = criteria->startObject; |
| if (!startObject) |
| startObject = this; |
| |
| bool isForward = criteria->searchDirection == AccessibilitySearchDirection::Next; |
| |
| // The first iteration of the outer loop will examine the children of the start object for matches. However, when |
| // iterating backwards, the start object children should not be considered, so the loop is skipped ahead. We make an |
| // exception when no start object was specified because we want to search everything regardless of search direction. |
| AccessibilityObject* previousObject = nullptr; |
| if (!isForward && startObject != this) { |
| previousObject = startObject; |
| startObject = startObject->parentObjectUnignored(); |
| } |
| |
| // The outer loop steps up the parent chain each time (unignored is important here because otherwise elements would be searched twice) |
| for (AccessibilityObject* stopSearchElement = parentObjectUnignored(); startObject && startObject != stopSearchElement; startObject = startObject->parentObjectUnignored()) { |
| |
| // Only append the children after/before the previous element, so that the search does not check elements that are |
| // already behind/ahead of start element. |
| AccessibilityChildrenVector searchStack; |
| if (!criteria->immediateDescendantsOnly || startObject == this) |
| appendChildrenToArray(startObject, isForward, previousObject, searchStack); |
| |
| // This now does a DFS at the current level of the parent. |
| while (!searchStack.isEmpty()) { |
| AccessibilityObject* searchObject = searchStack.last().get(); |
| searchStack.removeLast(); |
| |
| if (objectMatchesSearchCriteriaWithResultLimit(searchObject, criteria, results)) |
| break; |
| |
| if (!criteria->immediateDescendantsOnly) |
| appendChildrenToArray(searchObject, isForward, 0, searchStack); |
| } |
| |
| if (results.size() >= criteria->resultsLimit) |
| break; |
| |
| // When moving backwards, the parent object needs to be checked, because technically it's "before" the starting element. |
| if (!isForward && startObject != this && objectMatchesSearchCriteriaWithResultLimit(startObject, criteria, results)) |
| break; |
| |
| previousObject = startObject; |
| } |
| } |
| |
| // Returns the range that is fewer positions away from the reference range. |
| // NOTE: The after range is expected to ACTUALLY be after the reference range and the before |
| // range is expected to ACTUALLY be before. These are not checked for performance reasons. |
| static RefPtr<Range> rangeClosestToRange(Range* referenceRange, RefPtr<Range>&& afterRange, RefPtr<Range>&& beforeRange) |
| { |
| if (!referenceRange) |
| return nullptr; |
| |
| // The treeScope for shadow nodes may not be the same scope as another element in a document. |
| // Comparisons may fail in that case, which are expected behavior and should not assert. |
| if (afterRange && (referenceRange->endPosition().isNull() || ((afterRange->startPosition().anchorNode()->compareDocumentPosition(*referenceRange->endPosition().anchorNode()) & Node::DOCUMENT_POSITION_DISCONNECTED) == Node::DOCUMENT_POSITION_DISCONNECTED))) |
| return nullptr; |
| ASSERT(!afterRange || afterRange->startPosition() >= referenceRange->endPosition()); |
| |
| if (beforeRange && (referenceRange->startPosition().isNull() || ((beforeRange->endPosition().anchorNode()->compareDocumentPosition(*referenceRange->startPosition().anchorNode()) & Node::DOCUMENT_POSITION_DISCONNECTED) == Node::DOCUMENT_POSITION_DISCONNECTED))) |
| return nullptr; |
| ASSERT(!beforeRange || beforeRange->endPosition() <= referenceRange->startPosition()); |
| |
| if (!afterRange && !beforeRange) |
| return nullptr; |
| if (afterRange && !beforeRange) |
| return afterRange; |
| if (!afterRange && beforeRange) |
| return beforeRange; |
| |
| unsigned positionsToAfterRange = Position::positionCountBetweenPositions(afterRange->startPosition(), referenceRange->endPosition()); |
| unsigned positionsToBeforeRange = Position::positionCountBetweenPositions(beforeRange->endPosition(), referenceRange->startPosition()); |
| |
| return positionsToAfterRange < positionsToBeforeRange ? afterRange : beforeRange; |
| } |
| |
| RefPtr<Range> AccessibilityObject::rangeOfStringClosestToRangeInDirection(Range* referenceRange, AccessibilitySearchDirection searchDirection, Vector<String>& searchStrings) const |
| { |
| Frame* frame = this->frame(); |
| if (!frame) |
| return nullptr; |
| |
| if (!referenceRange) |
| return nullptr; |
| |
| bool isBackwardSearch = searchDirection == AccessibilitySearchDirection::Previous; |
| FindOptions findOptions { { AtWordStarts, AtWordEnds, CaseInsensitive, StartInSelection } }; |
| if (isBackwardSearch) |
| findOptions |= Backwards; |
| |
| RefPtr<Range> closestStringRange = nullptr; |
| for (const auto& searchString : searchStrings) { |
| if (RefPtr<Range> searchStringRange = frame->editor().rangeOfString(searchString, referenceRange, findOptions)) { |
| if (!closestStringRange) |
| closestStringRange = searchStringRange; |
| else { |
| // If searching backward, use the trailing range edges to correctly determine which |
| // range is closest. Similarly, if searching forward, use the leading range edges. |
| Position closestStringPosition = isBackwardSearch ? closestStringRange->endPosition() : closestStringRange->startPosition(); |
| Position searchStringPosition = isBackwardSearch ? searchStringRange->endPosition() : searchStringRange->startPosition(); |
| |
| int closestPositionOffset = closestStringPosition.computeOffsetInContainerNode(); |
| int searchPositionOffset = searchStringPosition.computeOffsetInContainerNode(); |
| Node* closestContainerNode = closestStringPosition.containerNode(); |
| Node* searchContainerNode = searchStringPosition.containerNode(); |
| |
| short result = Range::compareBoundaryPoints(closestContainerNode, closestPositionOffset, searchContainerNode, searchPositionOffset).releaseReturnValue(); |
| if ((!isBackwardSearch && result > 0) || (isBackwardSearch && result < 0)) |
| closestStringRange = searchStringRange; |
| } |
| } |
| } |
| return closestStringRange; |
| } |
| |
| // Returns the range of the entire document if there is no selection. |
| RefPtr<Range> AccessibilityObject::selectionRange() const |
| { |
| Frame* frame = this->frame(); |
| if (!frame) |
| return nullptr; |
| |
| const VisibleSelection& selection = frame->selection().selection(); |
| if (!selection.isNone()) |
| return selection.firstRange(); |
| |
| return Range::create(*frame->document()); |
| } |
| |
| RefPtr<Range> AccessibilityObject::elementRange() const |
| { |
| return AXObjectCache::rangeForNodeContents(node()); |
| } |
| |
| String AccessibilityObject::selectText(AccessibilitySelectTextCriteria* criteria) |
| { |
| ASSERT(criteria); |
| |
| if (!criteria) |
| return String(); |
| |
| Frame* frame = this->frame(); |
| if (!frame) |
| return String(); |
| |
| AccessibilitySelectTextActivity& activity = criteria->activity; |
| AccessibilitySelectTextAmbiguityResolution& ambiguityResolution = criteria->ambiguityResolution; |
| String& replacementString = criteria->replacementString; |
| Vector<String>& searchStrings = criteria->searchStrings; |
| |
| RefPtr<Range> selectedStringRange = selectionRange(); |
| // When starting our search again, make this a zero length range so that search forwards will find this selected range if its appropriate. |
| selectedStringRange->setEnd(selectedStringRange->startContainer(), selectedStringRange->startOffset()); |
| |
| RefPtr<Range> closestAfterStringRange = nullptr; |
| RefPtr<Range> closestBeforeStringRange = nullptr; |
| // Search forward if necessary. |
| if (ambiguityResolution == AccessibilitySelectTextAmbiguityResolution::ClosestAfter || ambiguityResolution == AccessibilitySelectTextAmbiguityResolution::ClosestTo) |
| closestAfterStringRange = rangeOfStringClosestToRangeInDirection(selectedStringRange.get(), AccessibilitySearchDirection::Next, searchStrings); |
| // Search backward if necessary. |
| if (ambiguityResolution == AccessibilitySelectTextAmbiguityResolution::ClosestBefore || ambiguityResolution == AccessibilitySelectTextAmbiguityResolution::ClosestTo) |
| closestBeforeStringRange = rangeOfStringClosestToRangeInDirection(selectedStringRange.get(), AccessibilitySearchDirection::Previous, searchStrings); |
| |
| // Determine which candidate is closest to the selection and perform the activity. |
| if (RefPtr<Range> closestStringRange = rangeClosestToRange(selectedStringRange.get(), WTFMove(closestAfterStringRange), WTFMove(closestBeforeStringRange))) { |
| // If the search started within a text control, ensure that the result is inside that element. |
| if (element() && element()->isTextField()) { |
| if (!closestStringRange->startContainer().isDescendantOrShadowDescendantOf(element()) || !closestStringRange->endContainer().isDescendantOrShadowDescendantOf(element())) |
| return String(); |
| } |
| |
| String closestString = closestStringRange->text(); |
| bool replaceSelection = false; |
| if (frame->selection().setSelectedRange(closestStringRange.get(), DOWNSTREAM, true)) { |
| switch (activity) { |
| case AccessibilitySelectTextActivity::FindAndCapitalize: |
| replacementString = capitalize(closestString, ' '); // FIXME: Needs to take locale into account to work correctly. |
| replaceSelection = true; |
| break; |
| case AccessibilitySelectTextActivity::FindAndUppercase: |
| replacementString = closestString.convertToUppercaseWithoutLocale(); // FIXME: Needs locale to work correctly. |
| replaceSelection = true; |
| break; |
| case AccessibilitySelectTextActivity::FindAndLowercase: |
| replacementString = closestString.convertToLowercaseWithoutLocale(); // FIXME: Needs locale to work correctly. |
| replaceSelection = true; |
| break; |
| case AccessibilitySelectTextActivity::FindAndReplace: { |
| replaceSelection = true; |
| // When applying find and replace activities, we want to match the capitalization of the replaced text, |
| // (unless we're replacing with an abbreviation.) |
| if (closestString.length() > 0 && replacementString.length() > 2 && replacementString != replacementString.convertToUppercaseWithoutLocale()) { |
| if (closestString[0] == u_toupper(closestString[0])) |
| replacementString = capitalize(replacementString, ' '); // FIXME: Needs to take locale into account to work correctly. |
| else |
| replacementString = replacementString.convertToLowercaseWithoutLocale(); // FIXME: Needs locale to work correctly. |
| } |
| break; |
| } |
| case AccessibilitySelectTextActivity::FindAndSelect: |
| break; |
| } |
| |
| // A bit obvious, but worth noting the API contract for this method is that we should |
| // return the replacement string when replacing, but the selected string if not. |
| if (replaceSelection) { |
| frame->editor().replaceSelectionWithText(replacementString, true, true); |
| return replacementString; |
| } |
| |
| return closestString; |
| } |
| } |
| |
| return String(); |
| } |
| |
| bool AccessibilityObject::hasAttributesRequiredForInclusion() const |
| { |
| // These checks are simplified in the interest of execution speed. |
| if (!getAttribute(aria_helpAttr).isEmpty() |
| || !getAttribute(aria_describedbyAttr).isEmpty() |
| || !getAttribute(altAttr).isEmpty() |
| || !getAttribute(titleAttr).isEmpty()) |
| return true; |
| |
| #if ENABLE(MATHML) |
| if (!getAttribute(MathMLNames::alttextAttr).isEmpty()) |
| return true; |
| #endif |
| |
| return false; |
| } |
| |
| bool AccessibilityObject::isARIAInput(AccessibilityRole ariaRole) |
| { |
| return ariaRole == AccessibilityRole::RadioButton || ariaRole == AccessibilityRole::CheckBox || ariaRole == AccessibilityRole::TextField || ariaRole == AccessibilityRole::Switch || ariaRole == AccessibilityRole::SearchField; |
| } |
| |
| bool AccessibilityObject::isARIAControl(AccessibilityRole ariaRole) |
| { |
| return isARIAInput(ariaRole) || ariaRole == AccessibilityRole::TextArea || ariaRole == AccessibilityRole::Button || ariaRole == AccessibilityRole::ComboBox || ariaRole == AccessibilityRole::Slider; |
| } |
| |
| bool AccessibilityObject::isRangeControl() const |
| { |
| switch (roleValue()) { |
| case AccessibilityRole::ProgressIndicator: |
| case AccessibilityRole::Slider: |
| case AccessibilityRole::ScrollBar: |
| case AccessibilityRole::SpinButton: |
| return true; |
| case AccessibilityRole::Splitter: |
| return canSetFocusAttribute(); |
| default: |
| return false; |
| } |
| } |
| |
| bool AccessibilityObject::isMeter() const |
| { |
| #if ENABLE(METER_ELEMENT) |
| RenderObject* renderer = this->renderer(); |
| return renderer && renderer->isMeter(); |
| #else |
| return false; |
| #endif |
| } |
| |
| IntPoint AccessibilityObject::clickPoint() |
| { |
| LayoutRect rect = elementRect(); |
| return roundedIntPoint(LayoutPoint(rect.x() + rect.width() / 2, rect.y() + rect.height() / 2)); |
| } |
| |
| IntRect AccessibilityObject::boundingBoxForQuads(RenderObject* obj, const Vector<FloatQuad>& quads) |
| { |
| ASSERT(obj); |
| if (!obj) |
| return IntRect(); |
| |
| FloatRect result; |
| for (const auto& quad : quads) { |
| FloatRect r = quad.enclosingBoundingBox(); |
| if (!r.isEmpty()) { |
| if (obj->style().hasAppearance()) |
| obj->theme().adjustRepaintRect(*obj, r); |
| result.unite(r); |
| } |
| } |
| return snappedIntRect(LayoutRect(result)); |
| } |
| |
| bool AccessibilityObject::press() |
| { |
| // The presence of the actionElement will confirm whether we should even attempt a press. |
| Element* actionElem = actionElement(); |
| if (!actionElem) |
| return false; |
| if (Frame* f = actionElem->document().frame()) |
| f->loader().resetMultipleFormSubmissionProtection(); |
| |
| // Hit test at this location to determine if there is a sub-node element that should act |
| // as the target of the action. |
| Element* hitTestElement = nullptr; |
| Document* document = this->document(); |
| if (document) { |
| HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::AccessibilityHitTest); |
| HitTestResult hitTestResult(clickPoint()); |
| document->renderView()->hitTest(request, hitTestResult); |
| if (hitTestResult.innerNode()) { |
| Node* innerNode = hitTestResult.innerNode()->deprecatedShadowAncestorNode(); |
| if (is<Element>(*innerNode)) |
| hitTestElement = downcast<Element>(innerNode); |
| else if (innerNode) |
| hitTestElement = innerNode->parentElement(); |
| } |
| } |
| |
| |
| // Prefer the actionElement instead of this node, if the actionElement is inside this node. |
| Element* pressElement = this->element(); |
| if (!pressElement || actionElem->isDescendantOf(*pressElement)) |
| pressElement = actionElem; |
| |
| ASSERT(pressElement); |
| // Prefer the hit test element, if it is inside the target element. |
| if (hitTestElement && hitTestElement->isDescendantOf(*pressElement)) |
| pressElement = hitTestElement; |
| |
| // dispatch accessibleclick event |
| if (auto* cache = axObjectCache()) { |
| if (auto* pressObject = cache->getOrCreate(pressElement)) { |
| if (pressObject->dispatchAccessibilityEventWithType(AccessibilityEventType::Click)) |
| return true; |
| } |
| } |
| |
| UserGestureIndicator gestureIndicator(ProcessingUserGesture, document); |
| |
| bool dispatchedTouchEvent = false; |
| #if PLATFORM(IOS) |
| if (hasTouchEventListener()) |
| dispatchedTouchEvent = dispatchTouchEvent(); |
| #endif |
| if (!dispatchedTouchEvent) |
| pressElement->accessKeyAction(true); |
| |
| return true; |
| } |
| |
| bool AccessibilityObject::dispatchTouchEvent() |
| { |
| #if ENABLE(IOS_TOUCH_EVENTS) |
| if (auto* frame = mainFrame()) |
| return frame->eventHandler().dispatchSimulatedTouchEvent(clickPoint()); |
| #endif |
| return false; |
| } |
| |
| Frame* AccessibilityObject::frame() const |
| { |
| Node* node = this->node(); |
| if (!node) |
| return nullptr; |
| |
| return node->document().frame(); |
| } |
| |
| Frame* AccessibilityObject::mainFrame() const |
| { |
| Document* document = topDocument(); |
| if (!document) |
| return nullptr; |
| |
| Frame* frame = document->frame(); |
| if (!frame) |
| return nullptr; |
| |
| return &frame->mainFrame(); |
| } |
| |
| Document* AccessibilityObject::topDocument() const |
| { |
| if (!document()) |
| return nullptr; |
| return &document()->topDocument(); |
| } |
| |
| String AccessibilityObject::language() const |
| { |
| const AtomicString& lang = getAttribute(langAttr); |
| if (!lang.isEmpty()) |
| return lang; |
| |
| AccessibilityObject* parent = parentObject(); |
| |
| // as a last resort, fall back to the content language specified in the meta tag |
| if (!parent) { |
| Document* doc = document(); |
| if (doc) |
| return doc->contentLanguage(); |
| return nullAtom(); |
| } |
| |
| return parent->language(); |
| } |
| |
| VisiblePositionRange AccessibilityObject::visiblePositionRangeForUnorderedPositions(const VisiblePosition& visiblePos1, const VisiblePosition& visiblePos2) const |
| { |
| if (visiblePos1.isNull() || visiblePos2.isNull()) |
| return VisiblePositionRange(); |
| |
| // If there's no common tree scope between positions, return early. |
| if (!commonTreeScope(visiblePos1.deepEquivalent().deprecatedNode(), visiblePos2.deepEquivalent().deprecatedNode())) |
| return VisiblePositionRange(); |
| |
| VisiblePosition startPos; |
| VisiblePosition endPos; |
| bool alreadyInOrder; |
| |
| // upstream is ordered before downstream for the same position |
| if (visiblePos1 == visiblePos2 && visiblePos2.affinity() == UPSTREAM) |
| alreadyInOrder = false; |
| |
| // use selection order to see if the positions are in order |
| else |
| alreadyInOrder = VisibleSelection(visiblePos1, visiblePos2).isBaseFirst(); |
| |
| if (alreadyInOrder) { |
| startPos = visiblePos1; |
| endPos = visiblePos2; |
| } else { |
| startPos = visiblePos2; |
| endPos = visiblePos1; |
| } |
| |
| return VisiblePositionRange(startPos, endPos); |
| } |
| |
| VisiblePositionRange AccessibilityObject::positionOfLeftWord(const VisiblePosition& visiblePos) const |
| { |
| VisiblePosition startPosition = startOfWord(visiblePos, LeftWordIfOnBoundary); |
| VisiblePosition endPosition = endOfWord(startPosition); |
| return VisiblePositionRange(startPosition, endPosition); |
| } |
| |
| VisiblePositionRange AccessibilityObject::positionOfRightWord(const VisiblePosition& visiblePos) const |
| { |
| VisiblePosition startPosition = startOfWord(visiblePos, RightWordIfOnBoundary); |
| VisiblePosition endPosition = endOfWord(startPosition); |
| return VisiblePositionRange(startPosition, endPosition); |
| } |
| |
| static VisiblePosition updateAXLineStartForVisiblePosition(const VisiblePosition& visiblePosition) |
| { |
| // A line in the accessibility sense should include floating objects, such as aligned image, as part of a line. |
| // So let's update the position to include that. |
| VisiblePosition tempPosition; |
| VisiblePosition startPosition = visiblePosition; |
| while (true) { |
| tempPosition = startPosition.previous(); |
| if (tempPosition.isNull()) |
| break; |
| Position p = tempPosition.deepEquivalent(); |
| RenderObject* renderer = p.deprecatedNode()->renderer(); |
| if (!renderer || (renderer->isRenderBlock() && !p.deprecatedEditingOffset())) |
| break; |
| if (!RenderedPosition(tempPosition).isNull()) |
| break; |
| startPosition = tempPosition; |
| } |
| |
| return startPosition; |
| } |
| |
| VisiblePositionRange AccessibilityObject::leftLineVisiblePositionRange(const VisiblePosition& visiblePos) const |
| { |
| if (visiblePos.isNull()) |
| return VisiblePositionRange(); |
| |
| // make a caret selection for the position before marker position (to make sure |
| // we move off of a line start) |
| VisiblePosition prevVisiblePos = visiblePos.previous(); |
| if (prevVisiblePos.isNull()) |
| return VisiblePositionRange(); |
| |
| VisiblePosition startPosition = startOfLine(prevVisiblePos); |
| |
| // keep searching for a valid line start position. Unless the VisiblePosition is at the very beginning, there should |
| // always be a valid line range. However, startOfLine will return null for position next to a floating object, |
| // since floating object doesn't really belong to any line. |
| // This check will reposition the marker before the floating object, to ensure we get a line start. |
| if (startPosition.isNull()) { |
| while (startPosition.isNull() && prevVisiblePos.isNotNull()) { |
| prevVisiblePos = prevVisiblePos.previous(); |
| startPosition = startOfLine(prevVisiblePos); |
| } |
| } else |
| startPosition = updateAXLineStartForVisiblePosition(startPosition); |
| |
| VisiblePosition endPosition = endOfLine(prevVisiblePos); |
| return VisiblePositionRange(startPosition, endPosition); |
| } |
| |
| VisiblePositionRange AccessibilityObject::rightLineVisiblePositionRange(const VisiblePosition& visiblePos) const |
| { |
| if (visiblePos.isNull()) |
| return VisiblePositionRange(); |
| |
| // make sure we move off of a line end |
| VisiblePosition nextVisiblePos = visiblePos.next(); |
| if (nextVisiblePos.isNull()) |
| return VisiblePositionRange(); |
| |
| VisiblePosition startPosition = startOfLine(nextVisiblePos); |
| |
| // fetch for a valid line start position |
| if (startPosition.isNull()) { |
| startPosition = visiblePos; |
| nextVisiblePos = nextVisiblePos.next(); |
| } else |
| startPosition = updateAXLineStartForVisiblePosition(startPosition); |
| |
| VisiblePosition endPosition = endOfLine(nextVisiblePos); |
| |
| // as long as the position hasn't reached the end of the doc, keep searching for a valid line end position |
| // Unless the VisiblePosition is at the very end, there should always be a valid line range. However, endOfLine will |
| // return null for position by a floating object, since floating object doesn't really belong to any line. |
| // This check will reposition the marker after the floating object, to ensure we get a line end. |
| while (endPosition.isNull() && nextVisiblePos.isNotNull()) { |
| nextVisiblePos = nextVisiblePos.next(); |
| endPosition = endOfLine(nextVisiblePos); |
| } |
| |
| return VisiblePositionRange(startPosition, endPosition); |
| } |
| |
| VisiblePositionRange AccessibilityObject::sentenceForPosition(const VisiblePosition& visiblePos) const |
| { |
| // FIXME: FO 2 IMPLEMENT (currently returns incorrect answer) |
| // Related? <rdar://problem/3927736> Text selection broken in 8A336 |
| VisiblePosition startPosition = startOfSentence(visiblePos); |
| VisiblePosition endPosition = endOfSentence(startPosition); |
| return VisiblePositionRange(startPosition, endPosition); |
| } |
| |
| VisiblePositionRange AccessibilityObject::paragraphForPosition(const VisiblePosition& visiblePos) const |
| { |
| VisiblePosition startPosition = startOfParagraph(visiblePos); |
| VisiblePosition endPosition = endOfParagraph(startPosition); |
| return VisiblePositionRange(startPosition, endPosition); |
| } |
| |
| static VisiblePosition startOfStyleRange(const VisiblePosition& visiblePos) |
| { |
| RenderObject* renderer = visiblePos.deepEquivalent().deprecatedNode()->renderer(); |
| RenderObject* startRenderer = renderer; |
| auto* style = &renderer->style(); |
| |
| // traverse backward by renderer to look for style change |
| for (RenderObject* r = renderer->previousInPreOrder(); r; r = r->previousInPreOrder()) { |
| // skip non-leaf nodes |
| if (r->firstChildSlow()) |
| continue; |
| |
| // stop at style change |
| if (&r->style() != style) |
| break; |
| |
| // remember match |
| startRenderer = r; |
| } |
| |
| return firstPositionInOrBeforeNode(startRenderer->node()); |
| } |
| |
| static VisiblePosition endOfStyleRange(const VisiblePosition& visiblePos) |
| { |
| RenderObject* renderer = visiblePos.deepEquivalent().deprecatedNode()->renderer(); |
| RenderObject* endRenderer = renderer; |
| const RenderStyle& style = renderer->style(); |
| |
| // traverse forward by renderer to look for style change |
| for (RenderObject* r = renderer->nextInPreOrder(); r; r = r->nextInPreOrder()) { |
| // skip non-leaf nodes |
| if (r->firstChildSlow()) |
| continue; |
| |
| // stop at style change |
| if (&r->style() != &style) |
| break; |
| |
| // remember match |
| endRenderer = r; |
| } |
| |
| return lastPositionInOrAfterNode(endRenderer->node()); |
| } |
| |
| VisiblePositionRange AccessibilityObject::styleRangeForPosition(const VisiblePosition& visiblePos) const |
| { |
| if (visiblePos.isNull()) |
| return VisiblePositionRange(); |
| |
| return VisiblePositionRange(startOfStyleRange(visiblePos), endOfStyleRange(visiblePos)); |
| } |
| |
| // NOTE: Consider providing this utility method as AX API |
| VisiblePositionRange AccessibilityObject::visiblePositionRangeForRange(const PlainTextRange& range) const |
| { |
| unsigned textLength = getLengthForTextRange(); |
| if (range.start + range.length > textLength) |
| return VisiblePositionRange(); |
| |
| VisiblePosition startPosition = visiblePositionForIndex(range.start); |
| startPosition.setAffinity(DOWNSTREAM); |
| VisiblePosition endPosition = visiblePositionForIndex(range.start + range.length); |
| return VisiblePositionRange(startPosition, endPosition); |
| } |
| |
| RefPtr<Range> AccessibilityObject::rangeForPlainTextRange(const PlainTextRange& range) const |
| { |
| unsigned textLength = getLengthForTextRange(); |
| if (range.start + range.length > textLength) |
| return nullptr; |
| |
| if (AXObjectCache* cache = axObjectCache()) { |
| CharacterOffset start = cache->characterOffsetForIndex(range.start, this); |
| CharacterOffset end = cache->characterOffsetForIndex(range.start + range.length, this); |
| return cache->rangeForUnorderedCharacterOffsets(start, end); |
| } |
| return nullptr; |
| } |
| |
| VisiblePositionRange AccessibilityObject::lineRangeForPosition(const VisiblePosition& visiblePosition) const |
| { |
| VisiblePosition startPosition = startOfLine(visiblePosition); |
| VisiblePosition endPosition = endOfLine(visiblePosition); |
| return VisiblePositionRange(startPosition, endPosition); |
| } |
| |
| bool AccessibilityObject::replacedNodeNeedsCharacter(Node* replacedNode) |
| { |
| // we should always be given a rendered node and a replaced node, but be safe |
| // replaced nodes are either attachments (widgets) or images |
| if (!replacedNode || !isRendererReplacedElement(replacedNode->renderer()) || replacedNode->isTextNode()) |
| return false; |
| |
| // create an AX object, but skip it if it is not supposed to be seen |
| AccessibilityObject* object = replacedNode->renderer()->document().axObjectCache()->getOrCreate(replacedNode); |
| if (object->accessibilityIsIgnored()) |
| return false; |
| |
| return true; |
| } |
| |
| // Finds a RenderListItem parent give a node. |
| static RenderListItem* renderListItemContainerForNode(Node* node) |
| { |
| for (; node; node = node->parentNode()) { |
| RenderBoxModelObject* renderer = node->renderBoxModelObject(); |
| if (is<RenderListItem>(renderer)) |
| return downcast<RenderListItem>(renderer); |
| } |
| return nullptr; |
| } |
| |
| static String listMarkerTextForNode(Node* node) |
| { |
| RenderListItem* listItem = renderListItemContainerForNode(node); |
| if (!listItem) |
| return String(); |
| |
| // If this is in a list item, we need to manually add the text for the list marker |
| // because a RenderListMarker does not have a Node equivalent and thus does not appear |
| // when iterating text. |
| return listItem->markerTextWithSuffix(); |
| } |
| |
| // Returns the text associated with a list marker if this node is contained within a list item. |
| String AccessibilityObject::listMarkerTextForNodeAndPosition(Node* node, const VisiblePosition& visiblePositionStart) |
| { |
| // If the range does not contain the start of the line, the list marker text should not be included. |
| if (!isStartOfLine(visiblePositionStart)) |
| return String(); |
| |
| // We should speak the list marker only for the first line. |
| RenderListItem* listItem = renderListItemContainerForNode(node); |
| if (!listItem) |
| return String(); |
| if (!inSameLine(visiblePositionStart, firstPositionInNode(&listItem->element()))) |
| return String(); |
| |
| return listMarkerTextForNode(node); |
| } |
| |
| String AccessibilityObject::stringForRange(RefPtr<Range> range) const |
| { |
| if (!range) |
| return String(); |
| |
| TextIterator it(range.get()); |
| if (it.atEnd()) |
| return String(); |
| |
| StringBuilder builder; |
| for (; !it.atEnd(); it.advance()) { |
| // non-zero length means textual node, zero length means replaced node (AKA "attachments" in AX) |
| if (it.text().length()) { |
| // Add a textual representation for list marker text. |
| // Don't add list marker text for new line character. |
| if (it.text().length() != 1 || !isSpaceOrNewline(it.text()[0])) |
| builder.append(listMarkerTextForNodeAndPosition(it.node(), VisiblePosition(range->startPosition()))); |
| it.appendTextToStringBuilder(builder); |
| } else { |
| // locate the node and starting offset for this replaced range |
| Node& node = it.range()->startContainer(); |
| ASSERT(&node == &it.range()->endContainer()); |
| int offset = it.range()->startOffset(); |
| if (replacedNodeNeedsCharacter(node.traverseToChildAt(offset))) |
| builder.append(objectReplacementCharacter); |
| } |
| } |
| |
| return builder.toString(); |
| } |
| |
| String AccessibilityObject::stringForVisiblePositionRange(const VisiblePositionRange& visiblePositionRange) |
| { |
| if (visiblePositionRange.isNull()) |
| return String(); |
| |
| StringBuilder builder; |
| RefPtr<Range> range = makeRange(visiblePositionRange.start, visiblePositionRange.end); |
| for (TextIterator it(range.get()); !it.atEnd(); it.advance()) { |
| // non-zero length means textual node, zero length means replaced node (AKA "attachments" in AX) |
| if (it.text().length()) { |
| // Add a textual representation for list marker text. |
| builder.append(listMarkerTextForNodeAndPosition(it.node(), visiblePositionRange.start)); |
| it.appendTextToStringBuilder(builder); |
| } else { |
| // locate the node and starting offset for this replaced range |
| Node& node = it.range()->startContainer(); |
| ASSERT(&node == &it.range()->endContainer()); |
| int offset = it.range()->startOffset(); |
| if (replacedNodeNeedsCharacter(node.traverseToChildAt(offset))) |
| builder.append(objectReplacementCharacter); |
| } |
| } |
| |
| return builder.toString(); |
| } |
| |
| int AccessibilityObject::lengthForVisiblePositionRange(const VisiblePositionRange& visiblePositionRange) const |
| { |
| // FIXME: Multi-byte support |
| if (visiblePositionRange.isNull()) |
| return -1; |
| |
| int length = 0; |
| RefPtr<Range> range = makeRange(visiblePositionRange.start, visiblePositionRange.end); |
| for (TextIterator it(range.get()); !it.atEnd(); it.advance()) { |
| // non-zero length means textual node, zero length means replaced node (AKA "attachments" in AX) |
| if (it.text().length()) |
| length += it.text().length(); |
| else { |
| // locate the node and starting offset for this replaced range |
| Node& node = it.range()->startContainer(); |
| ASSERT(&node == &it.range()->endContainer()); |
| int offset = it.range()->startOffset(); |
| |
| if (replacedNodeNeedsCharacter(node.traverseToChildAt(offset))) |
| ++length; |
| } |
| } |
| |
| return length; |
| } |
| |
| VisiblePosition AccessibilityObject::visiblePositionForBounds(const IntRect& rect, AccessibilityVisiblePositionForBounds visiblePositionForBounds) const |
| { |
| if (rect.isEmpty()) |
| return VisiblePosition(); |
| |
| auto* mainFrame = this->mainFrame(); |
| if (!mainFrame) |
| return VisiblePosition(); |
| |
| // FIXME: Add support for right-to-left languages. |
| IntPoint corner = (visiblePositionForBounds == AccessibilityVisiblePositionForBounds::First) ? rect.minXMinYCorner() : rect.maxXMaxYCorner(); |
| VisiblePosition position = mainFrame->visiblePositionForPoint(corner); |
| |
| if (rect.contains(position.absoluteCaretBounds().center())) |
| return position; |
| |
| // If the initial position is located outside the bounds adjust it incrementally as needed. |
| VisiblePosition nextPosition = position.next(); |
| VisiblePosition previousPosition = position.previous(); |
| while (nextPosition.isNotNull() || previousPosition.isNotNull()) { |
| if (rect.contains(nextPosition.absoluteCaretBounds().center())) |
| return nextPosition; |
| if (rect.contains(previousPosition.absoluteCaretBounds().center())) |
| return previousPosition; |
| |
| nextPosition = nextPosition.next(); |
| previousPosition = previousPosition.previous(); |
| } |
| |
| return VisiblePosition(); |
| } |
| |
| VisiblePosition AccessibilityObject::nextWordEnd(const VisiblePosition& visiblePos) const |
| { |
| if (visiblePos.isNull()) |
| return VisiblePosition(); |
| |
| // make sure we move off of a word end |
| VisiblePosition nextVisiblePos = visiblePos.next(); |
| if (nextVisiblePos.isNull()) |
| return VisiblePosition(); |
| |
| return endOfWord(nextVisiblePos, LeftWordIfOnBoundary); |
| } |
| |
| VisiblePosition AccessibilityObject::previousWordStart(const VisiblePosition& visiblePos) const |
| { |
| if (visiblePos.isNull()) |
| return VisiblePosition(); |
| |
| // make sure we move off of a word start |
| VisiblePosition prevVisiblePos = visiblePos.previous(); |
| if (prevVisiblePos.isNull()) |
| return VisiblePosition(); |
| |
| return startOfWord(prevVisiblePos, RightWordIfOnBoundary); |
| } |
| |
| VisiblePosition AccessibilityObject::nextLineEndPosition(const VisiblePosition& visiblePos) const |
| { |
| if (visiblePos.isNull()) |
| return VisiblePosition(); |
| |
| // to make sure we move off of a line end |
| VisiblePosition nextVisiblePos = visiblePos.next(); |
| if (nextVisiblePos.isNull()) |
| return VisiblePosition(); |
| |
| VisiblePosition endPosition = endOfLine(nextVisiblePos); |
| |
| // as long as the position hasn't reached the end of the doc, keep searching for a valid line end position |
| // There are cases like when the position is next to a floating object that'll return null for end of line. This code will avoid returning null. |
| while (endPosition.isNull() && nextVisiblePos.isNotNull()) { |
| nextVisiblePos = nextVisiblePos.next(); |
| endPosition = endOfLine(nextVisiblePos); |
| } |
| |
| return endPosition; |
| } |
| |
| VisiblePosition AccessibilityObject::previousLineStartPosition(const VisiblePosition& visiblePos) const |
| { |
| if (visiblePos.isNull()) |
| return VisiblePosition(); |
| |
| // make sure we move off of a line start |
| VisiblePosition prevVisiblePos = visiblePos.previous(); |
| if (prevVisiblePos.isNull()) |
| return VisiblePosition(); |
| |
| VisiblePosition startPosition = startOfLine(prevVisiblePos); |
| |
| // as long as the position hasn't reached the beginning of the doc, keep searching for a valid line start position |
| // There are cases like when the position is next to a floating object that'll return null for start of line. This code will avoid returning null. |
| if (startPosition.isNull()) { |
| while (startPosition.isNull() && prevVisiblePos.isNotNull()) { |
| prevVisiblePos = prevVisiblePos.previous(); |
| startPosition = startOfLine(prevVisiblePos); |
| } |
| } else |
| startPosition = updateAXLineStartForVisiblePosition(startPosition); |
| |
| return startPosition; |
| } |
| |
| VisiblePosition AccessibilityObject::nextSentenceEndPosition(const VisiblePosition& visiblePos) const |
| { |
| // FIXME: FO 2 IMPLEMENT (currently returns incorrect answer) |
| // Related? <rdar://problem/3927736> Text selection broken in 8A336 |
| if (visiblePos.isNull()) |
| return VisiblePosition(); |
| |
| // make sure we move off of a sentence end |
| VisiblePosition nextVisiblePos = visiblePos.next(); |
| if (nextVisiblePos.isNull()) |
| return VisiblePosition(); |
| |
| // an empty line is considered a sentence. If it's skipped, then the sentence parser will not |
| // see this empty line. Instead, return the end position of the empty line. |
| VisiblePosition endPosition; |
| |
| String lineString = plainText(makeRange(startOfLine(nextVisiblePos), endOfLine(nextVisiblePos)).get()); |
| if (lineString.isEmpty()) |
| endPosition = nextVisiblePos; |
| else |
| endPosition = endOfSentence(nextVisiblePos); |
| |
| return endPosition; |
| } |
| |
| VisiblePosition AccessibilityObject::previousSentenceStartPosition(const VisiblePosition& visiblePos) const |
| { |
| // FIXME: FO 2 IMPLEMENT (currently returns incorrect answer) |
| // Related? <rdar://problem/3927736> Text selection broken in 8A336 |
| if (visiblePos.isNull()) |
| return VisiblePosition(); |
| |
| // make sure we move off of a sentence start |
| VisiblePosition previousVisiblePos = visiblePos.previous(); |
| if (previousVisiblePos.isNull()) |
| return VisiblePosition(); |
| |
| // treat empty line as a separate sentence. |
| VisiblePosition startPosition; |
| |
| String lineString = plainText(makeRange(startOfLine(previousVisiblePos), endOfLine(previousVisiblePos)).get()); |
| if (lineString.isEmpty()) |
| startPosition = previousVisiblePos; |
| else |
| startPosition = startOfSentence(previousVisiblePos); |
| |
| return startPosition; |
| } |
| |
| VisiblePosition AccessibilityObject::nextParagraphEndPosition(const VisiblePosition& visiblePos) const |
| { |
| if (visiblePos.isNull()) |
| return VisiblePosition(); |
| |
| // make sure we move off of a paragraph end |
| VisiblePosition nextPos = visiblePos.next(); |
| if (nextPos.isNull()) |
| return VisiblePosition(); |
| |
| return endOfParagraph(nextPos); |
| } |
| |
| VisiblePosition AccessibilityObject::previousParagraphStartPosition(const VisiblePosition& visiblePos) const |
| { |
| if (visiblePos.isNull()) |
| return VisiblePosition(); |
| |
| // make sure we move off of a paragraph start |
| VisiblePosition previousPos = visiblePos.previous(); |
| if (previousPos.isNull()) |
| return VisiblePosition(); |
| |
| return startOfParagraph(previousPos); |
| } |
| |
| AccessibilityObject* AccessibilityObject::accessibilityObjectForPosition(const VisiblePosition& visiblePos) const |
| { |
| if (visiblePos.isNull()) |
| return nullptr; |
| |
| RenderObject* obj = visiblePos.deepEquivalent().deprecatedNode()->renderer(); |
| if (!obj) |
| return nullptr; |
| |
| return obj->document().axObjectCache()->getOrCreate(obj); |
| } |
| |
| // If you call node->hasEditableStyle() since that will return true if an ancestor is editable. |
| // This only returns true if this is the element that actually has the contentEditable attribute set. |
| bool AccessibilityObject::hasContentEditableAttributeSet() const |
| { |
| return contentEditableAttributeIsEnabled(element()); |
| } |
| |
| bool AccessibilityObject::supportsReadOnly() const |
| { |
| AccessibilityRole role = roleValue(); |
| |
| return role == AccessibilityRole::CheckBox |
| || role == AccessibilityRole::ColumnHeader |
| || role == AccessibilityRole::ComboBox |
| || role == AccessibilityRole::Grid |
| || role == AccessibilityRole::GridCell |
| || role == AccessibilityRole::ListBox |
| || role == AccessibilityRole::MenuItemCheckbox |
| || role == AccessibilityRole::MenuItemRadio |
| || role == AccessibilityRole::RadioGroup |
| || role == AccessibilityRole::RowHeader |
| || role == AccessibilityRole::SearchField |
| || role == AccessibilityRole::Slider |
| || role == AccessibilityRole::SpinButton |
| || role == AccessibilityRole::Switch |
| || role == AccessibilityRole::TextField |
| || role == AccessibilityRole::TreeGrid |
| || isPasswordField(); |
| } |
| |
| String AccessibilityObject::readOnlyValue() const |
| { |
| if (!hasAttribute(aria_readonlyAttr)) |
| return ariaRoleAttribute() != AccessibilityRole::Unknown && supportsReadOnly() ? "false" : String(); |
| |
| return getAttribute(aria_readonlyAttr).string().convertToASCIILowercase(); |
| } |
| |
| bool AccessibilityObject::supportsAutoComplete() const |
| { |
| return (isComboBox() || isARIATextControl()) && hasAttribute(aria_autocompleteAttr); |
| } |
| |
| String AccessibilityObject::autoCompleteValue() const |
| { |
| const AtomicString& autoComplete = getAttribute(aria_autocompleteAttr); |
| if (equalLettersIgnoringASCIICase(autoComplete, "inline") |
| || equalLettersIgnoringASCIICase(autoComplete, "list") |
| || equalLettersIgnoringASCIICase(autoComplete, "both")) |
| return autoComplete; |
| |
| return "none"; |
| } |
| |
| bool AccessibilityObject::contentEditableAttributeIsEnabled(Element* element) |
| { |
| if (!element) |
| return false; |
| |
| const AtomicString& contentEditableValue = element->attributeWithoutSynchronization(contenteditableAttr); |
| if (contentEditableValue.isNull()) |
| return false; |
| |
| // Both "true" (case-insensitive) and the empty string count as true. |
| return contentEditableValue.isEmpty() || equalLettersIgnoringASCIICase(contentEditableValue, "true"); |
| } |
| |
| #if HAVE(ACCESSIBILITY) |
| int AccessibilityObject::lineForPosition(const VisiblePosition& visiblePos) const |
| { |
| if (visiblePos.isNull() || !node()) |
| return -1; |
| |
| // If the position is not in the same editable region as this AX object, return -1. |
| Node* containerNode = visiblePos.deepEquivalent().containerNode(); |
| if (!containerNode->containsIncludingShadowDOM(node()) && !node()->containsIncludingShadowDOM(containerNode)) |
| return -1; |
| |
| int lineCount = -1; |
| VisiblePosition currentVisiblePos = visiblePos; |
| VisiblePosition savedVisiblePos; |
| |
| // move up until we get to the top |
| // FIXME: This only takes us to the top of the rootEditableElement, not the top of the |
| // top document. |
| do { |
| savedVisiblePos = currentVisiblePos; |
| VisiblePosition prevVisiblePos = previousLinePosition(currentVisiblePos, 0, HasEditableAXRole); |
| currentVisiblePos = prevVisiblePos; |
| ++lineCount; |
| } while (currentVisiblePos.isNotNull() && !(inSameLine(currentVisiblePos, savedVisiblePos))); |
| |
| return lineCount; |
| } |
| #endif |
| |
| // NOTE: Consider providing this utility method as AX API |
| PlainTextRange AccessibilityObject::plainTextRangeForVisiblePositionRange(const VisiblePositionRange& positionRange) const |
| { |
| int index1 = index(positionRange.start); |
| int index2 = index(positionRange.end); |
| if (index1 < 0 || index2 < 0 || index1 > index2) |
| return PlainTextRange(); |
| |
| return PlainTextRange(index1, index2 - index1); |
| } |
| |
| // The composed character range in the text associated with this accessibility object that |
| // is specified by the given screen coordinates. This parameterized attribute returns the |
| // complete range of characters (including surrogate pairs of multi-byte glyphs) at the given |
| // screen coordinates. |
| // NOTE: This varies from AppKit when the point is below the last line. AppKit returns an |
| // an error in that case. We return textControl->text().length(), 1. Does this matter? |
| PlainTextRange AccessibilityObject::doAXRangeForPosition(const IntPoint& point) const |
| { |
| int i = index(visiblePositionForPoint(point)); |
| if (i < 0) |
| return PlainTextRange(); |
| |
| return PlainTextRange(i, 1); |
| } |
| |
| // Given a character index, the range of text associated with this accessibility object |
| // over which the style in effect at that character index applies. |
| PlainTextRange AccessibilityObject::doAXStyleRangeForIndex(unsigned index) const |
| { |
| VisiblePositionRange range = styleRangeForPosition(visiblePositionForIndex(index, false)); |
| return plainTextRangeForVisiblePositionRange(range); |
| } |
| |
| // Given an indexed character, the line number of the text associated with this accessibility |
| // object that contains the character. |
| unsigned AccessibilityObject::doAXLineForIndex(unsigned index) |
| { |
| return lineForPosition(visiblePositionForIndex(index, false)); |
| } |
| |
| #if HAVE(ACCESSIBILITY) |
| void AccessibilityObject::updateBackingStore() |
| { |
| if (!axObjectCache()) |
| return; |
| |
| // Updating the layout may delete this object. |
| RefPtr<AccessibilityObject> protectedThis(this); |
| if (auto* document = this->document()) { |
| if (!document->view()->layoutContext().isInRenderTreeLayout() && !document->inRenderTreeUpdate() && !document->inStyleRecalc()) |
| document->updateLayoutIgnorePendingStylesheets(); |
| } |
| updateChildrenIfNecessary(); |
| } |
| #endif |
| |
| ScrollView* AccessibilityObject::scrollViewAncestor() const |
| { |
| if (const AccessibilityObject* scrollParent = AccessibilityObject::matchedParent(*this, true, [] (const AccessibilityObject& object) { |
| return is<AccessibilityScrollView>(object); |
| })) |
| return downcast<AccessibilityScrollView>(*scrollParent).scrollView(); |
| |
| return nullptr; |
| } |
| |
| Document* AccessibilityObject::document() const |
| { |
| FrameView* frameView = documentFrameView(); |
| if (!frameView) |
| return nullptr; |
| |
| return frameView->frame().document(); |
| } |
| |
| Page* AccessibilityObject::page() const |
| { |
| Document* document = this->document(); |
| if (!document) |
| return nullptr; |
| return document->page(); |
| } |
| |
| FrameView* AccessibilityObject::documentFrameView() const |
| { |
| const AccessibilityObject* object = this; |
| while (object && !object->isAccessibilityRenderObject()) |
| object = object->parentObject(); |
| |
| if (!object) |
| return nullptr; |
| |
| return object->documentFrameView(); |
| } |
| |
| #if HAVE(ACCESSIBILITY) |
| const AccessibilityObject::AccessibilityChildrenVector& AccessibilityObject::children(bool updateChildrenIfNeeded) |
| { |
| if (updateChildrenIfNeeded) |
| updateChildrenIfNecessary(); |
| |
| return m_children; |
| } |
| #endif |
| |
| void AccessibilityObject::updateChildrenIfNecessary() |
| { |
| if (!hasChildren()) { |
| // Enable the cache in case we end up adding a lot of children, we don't want to recompute axIsIgnored each time. |
| AXAttributeCacheEnabler enableCache(axObjectCache()); |
| addChildren(); |
| } |
| } |
| |
| void AccessibilityObject::clearChildren() |
| { |
| // Some objects have weak pointers to their parents and those associations need to be detached. |
| for (const auto& child : m_children) |
| child->detachFromParent(); |
| |
| m_children.clear(); |
| m_haveChildren = false; |
| } |
| |
| AccessibilityObject* AccessibilityObject::anchorElementForNode(Node* node) |
| { |
| RenderObject* obj = node->renderer(); |
| if (!obj) |
| return nullptr; |
| |
| RefPtr<AccessibilityObject> axObj = obj->document().axObjectCache()->getOrCreate(obj); |
| Element* anchor = axObj->anchorElement(); |
| if (!anchor) |
| return nullptr; |
| |
| RenderObject* anchorRenderer = anchor->renderer(); |
| if (!anchorRenderer) |
| return nullptr; |
| |
| return anchorRenderer->document().axObjectCache()->getOrCreate(anchorRenderer); |
| } |
| |
| AccessibilityObject* AccessibilityObject::headingElementForNode(Node* node) |
| { |
| if (!node) |
| return nullptr; |
| |
| RenderObject* renderObject = node->renderer(); |
| if (!renderObject) |
| return nullptr; |
| |
| AccessibilityObject* axObject = renderObject->document().axObjectCache()->getOrCreate(renderObject); |
| |
| return const_cast<AccessibilityObject*>(AccessibilityObject::matchedParent(*axObject, true, [] (const AccessibilityObject& object) { |
| return object.roleValue() == AccessibilityRole::Heading; |
| })); |
| } |
| |
| const AccessibilityObject* AccessibilityObject::matchedParent(const AccessibilityObject& object, bool includeSelf, const WTF::Function<bool(const AccessibilityObject&)>& matches) |
| { |
| const AccessibilityObject* parent = includeSelf ? &object : object.parentObject(); |
| for (; parent; parent = parent->parentObject()) { |
| if (matches(*parent)) |
| return parent; |
| } |
| return nullptr; |
| } |
| |
| void AccessibilityObject::ariaTreeRows(AccessibilityChildrenVector& result) |
| { |
| for (const auto& child : children()) { |
| // Add tree items as the rows. |
| if (child->roleValue() == AccessibilityRole::TreeItem) |
| result.append(child); |
| |
| // Now see if this item also has rows hiding inside of it. |
| child->ariaTreeRows(result); |
| } |
| } |
| |
| void AccessibilityObject::ariaTreeItemContent(AccessibilityChildrenVector& result) |
| { |
| // The ARIA tree item content are the item that are not other tree items or their containing groups. |
| for (const auto& child : children()) { |
| if (!child->isGroup() && child->roleValue() != AccessibilityRole::TreeItem) |
| result.append(child); |
| } |
| } |
| |
| void AccessibilityObject::ariaTreeItemDisclosedRows(AccessibilityChildrenVector& result) |
| { |
| for (const auto& obj : children()) { |
| // Add tree items as the rows. |
| if (obj->roleValue() == AccessibilityRole::TreeItem) |
| result.append(obj); |
| // If it's not a tree item, then descend into the group to find more tree items. |
| else |
| obj->ariaTreeRows(result); |
| } |
| } |
| |
| const String AccessibilityObject::defaultLiveRegionStatusForRole(AccessibilityRole role) |
| { |
| switch (role) { |
| case AccessibilityRole::ApplicationAlertDialog: |
| case AccessibilityRole::ApplicationAlert: |
| return ASCIILiteral("assertive"); |
| case AccessibilityRole::ApplicationLog: |
| case AccessibilityRole::ApplicationStatus: |
| return ASCIILiteral("polite"); |
| case AccessibilityRole::ApplicationTimer: |
| case AccessibilityRole::ApplicationMarquee: |
| return ASCIILiteral("off"); |
| default: |
| return nullAtom(); |
| } |
| } |
| |
| #if HAVE(ACCESSIBILITY) |
| const String& AccessibilityObject::actionVerb() const |
| { |
| #if !PLATFORM(IOS) |
| // FIXME: Need to add verbs for select elements. |
| static NeverDestroyed<const String> buttonAction(AXButtonActionVerb()); |
| static NeverDestroyed<const String> textFieldAction(AXTextFieldActionVerb()); |
| static NeverDestroyed<const String> radioButtonAction(AXRadioButtonActionVerb()); |
| static NeverDestroyed<const String> checkedCheckBoxAction(AXCheckedCheckBoxActionVerb()); |
| static NeverDestroyed<const String> uncheckedCheckBoxAction(AXUncheckedCheckBoxActionVerb()); |
| static NeverDestroyed<const String> linkAction(AXLinkActionVerb()); |
| static NeverDestroyed<const String> menuListAction(AXMenuListActionVerb()); |
| static NeverDestroyed<const String> menuListPopupAction(AXMenuListPopupActionVerb()); |
| static NeverDestroyed<const String> listItemAction(AXListItemActionVerb()); |
| |
| switch (roleValue()) { |
| case AccessibilityRole::Button: |
| case AccessibilityRole::ToggleButton: |
| return buttonAction; |
| case AccessibilityRole::TextField: |
| case AccessibilityRole::TextArea: |
| return textFieldAction; |
| case AccessibilityRole::RadioButton: |
| return radioButtonAction; |
| case AccessibilityRole::CheckBox: |
| case AccessibilityRole::Switch: |
| return isChecked() ? checkedCheckBoxAction : uncheckedCheckBoxAction; |
| case AccessibilityRole::Link: |
| case AccessibilityRole::WebCoreLink: |
| return linkAction; |
| case AccessibilityRole::PopUpButton: |
| return menuListAction; |
| case AccessibilityRole::MenuListPopup: |
| return menuListPopupAction; |
| case AccessibilityRole::ListItem: |
| return listItemAction; |
| default: |
| return nullAtom(); |
| } |
| #else |
| return nullAtom(); |
| #endif |
| } |
| #endif |
| |
| bool AccessibilityObject::ariaIsMultiline() const |
| { |
| return equalLettersIgnoringASCIICase(getAttribute(aria_multilineAttr), "true"); |
| } |
| |
| String AccessibilityObject::invalidStatus() const |
| { |
| String grammarValue = ASCIILiteral("grammar"); |
| String falseValue = ASCIILiteral("false"); |
| String spellingValue = ASCIILiteral("spelling"); |
| String trueValue = ASCIILiteral("true"); |
| String undefinedValue = ASCIILiteral("undefined"); |
| |
| // aria-invalid can return false (default), grammar, spelling, or true. |
| String ariaInvalid = stripLeadingAndTrailingHTMLSpaces(getAttribute(aria_invalidAttr)); |
| |
| if (ariaInvalid.isEmpty()) { |
| // We should expose invalid status for input types. |
| Node* node = this->node(); |
| if (node && is<HTMLInputElement>(*node)) { |
| HTMLInputElement& input = downcast<HTMLInputElement>(*node); |
| if (input.hasBadInput() || input.typeMismatch()) |
| return trueValue; |
| } |
| return falseValue; |
| } |
| |
| // If "false", "undefined" [sic, string value], empty, or missing, return "false". |
| if (ariaInvalid == falseValue || ariaInvalid == undefinedValue) |
| return falseValue; |
| // Besides true/false/undefined, the only tokens defined by WAI-ARIA 1.0... |
| // ...for @aria-invalid are "grammar" and "spelling". |
| if (ariaInvalid == grammarValue) |
| return grammarValue; |
| if (ariaInvalid == spellingValue) |
| return spellingValue; |
| // Any other non empty string should be treated as "true". |
| return trueValue; |
| } |
| |
| bool AccessibilityObject::supportsCurrent() const |
| { |
| return hasAttribute(aria_currentAttr); |
| } |
| |
| AccessibilityCurrentState AccessibilityObject::currentState() const |
| { |
| // aria-current can return false (default), true, page, step, location, date or time. |
| String currentStateValue = stripLeadingAndTrailingHTMLSpaces(getAttribute(aria_currentAttr)); |
| |
| // If "false", empty, or missing, return false state. |
| if (currentStateValue.isEmpty() || currentStateValue == "false") |
| return AccessibilityCurrentState::False; |
| |
| if (currentStateValue == "page") |
| return AccessibilityCurrentState::Page; |
| if (currentStateValue == "step") |
| return AccessibilityCurrentState::Step; |
| if (currentStateValue == "location") |
| return AccessibilityCurrentState::Location; |
| if (currentStateValue == "date") |
| return AccessibilityCurrentState::Date; |
| if (currentStateValue == "time") |
| return AccessibilityCurrentState::Time; |
| |
| // Any value not included in the list of allowed values should be treated as "true". |
| return AccessibilityCurrentState::True; |
| } |
| |
| String AccessibilityObject::currentValue() const |
| { |
| switch (currentState()) { |
| case AccessibilityCurrentState::False: |
| return "false"; |
| case AccessibilityCurrentState::Page: |
| return "page"; |
| case AccessibilityCurrentState::Step: |
| return "step"; |
| case AccessibilityCurrentState::Location: |
| return "location"; |
| case AccessibilityCurrentState::Time: |
| return "time"; |
| case AccessibilityCurrentState::Date: |
| return "date"; |
| default: |
| case AccessibilityCurrentState::True: |
| return "true"; |
| } |
| } |
| |
| bool AccessibilityObject::isModalDescendant(Node* modalNode) const |
| { |
| if (!modalNode || !this->element()) |
| return false; |
| |
| if (this->element() == modalNode) |
| return true; |
| |
| // ARIA 1.1 aria-modal, indicates whether an element is modal when displayed. |
| // For the decendants of the modal object, they should also be considered as aria-modal=true. |
| for (auto& ancestor : elementAncestors(this->element())) { |
| if (&ancestor == modalNode) |
| return true; |
| } |
| return false; |
| } |
| |
| bool AccessibilityObject::isModalNode() const |
| { |
| if (AXObjectCache* cache = axObjectCache()) |
| return node() && cache->modalNode() == node(); |
| |
| return false; |
| } |
| |
| bool AccessibilityObject::ignoredFromModalPresence() const |
| { |
| // We shouldn't ignore the top node. |
| if (!node() || !node()->parentNode()) |
| return false; |
| |
| AXObjectCache* cache = axObjectCache(); |
| if (!cache) |
| return false; |
| |
| // modalNode is the current displayed modal dialog. |
| Node* modalNode = cache->modalNode(); |
| if (!modalNode) |
| return false; |
| |
| // We only want to ignore the objects within the same frame as the modal dialog. |
| if (modalNode->document().frame() != this->frame()) |
| return false; |
| |
| return !isModalDescendant(modalNode); |
| } |
| |
| bool AccessibilityObject::hasTagName(const QualifiedName& tagName) const |
| { |
| Node* node = this->node(); |
| return is<Element>(node) && downcast<Element>(*node).hasTagName(tagName); |
| } |
| |
| bool AccessibilityObject::hasAttribute(const QualifiedName& attribute) const |
| { |
| Node* node = this->node(); |
| if (!is<Element>(node)) |
| return false; |
| |
| return downcast<Element>(*node).hasAttributeWithoutSynchronization(attribute); |
| } |
| |
| const AtomicString& AccessibilityObject::getAttribute(const QualifiedName& attribute) const |
| { |
| if (auto* element = this->element()) |
| return element->attributeWithoutSynchronization(attribute); |
| return nullAtom(); |
| } |
| |
| bool AccessibilityObject::shouldDispatchAccessibilityEvent() const |
| { |
| bool shouldDispatch = RuntimeEnabledFeatures::sharedFeatures().accessibilityObjectModelEnabled(); |
| #if ENABLE(ACCESSIBILITY_EVENTS) |
| return shouldDispatch &= this->page()->settings().accessibilityEventsEnabled(); |
| #endif |
| return shouldDispatch; |
| } |
| |
| bool AccessibilityObject::dispatchAccessibilityEvent(Event& event) const |
| { |
| if (!shouldDispatchAccessibilityEvent()) |
| return false; |
| |
| Vector<Element*> eventPath; |
| for (auto* parentObject = this; parentObject; parentObject = parentObject->parentObject()) { |
| if (parentObject->isWebArea()) |
| break; |
| if (auto* parentElement = parentObject->element()) |
| eventPath.append(parentElement); |
| } |
| |
| if (!eventPath.size()) |
| return false; |
| |
| EventDispatcher::dispatchEvent(eventPath, event); |
| |
| // return true if preventDefault() was called, so that we don't execute the fallback behavior. |
| return event.defaultPrevented(); |
| } |
| |
| bool AccessibilityObject::dispatchAccessibilityEventWithType(AccessibilityEventType type) const |
| { |
| AtomicString eventName; |
| switch (type) { |
| case AccessibilityEventType::ContextMenu: |
| eventName = eventNames().accessiblecontextmenuEvent; |
| break; |
| case AccessibilityEventType::Click: |
| eventName = eventNames().accessibleclickEvent; |
| break; |
| case AccessibilityEventType::Decrement: |
| eventName = eventNames().accessibledecrementEvent; |
| break; |
| case AccessibilityEventType::Dismiss: |
| eventName = eventNames().accessibledismissEvent; |
| break; |
| case AccessibilityEventType::Focus: |
| eventName = eventNames().accessiblefocusEvent; |
| break; |
| case AccessibilityEventType::Increment: |
| eventName = eventNames().accessibleincrementEvent; |
| break; |
| case AccessibilityEventType::ScrollIntoView: |
| eventName = eventNames().accessiblescrollintoviewEvent; |
| break; |
| case AccessibilityEventType::Select: |
| eventName = eventNames().accessibleselectEvent; |
| break; |
| default: |
| return false; |
| } |
| |
| auto event = Event::create(eventName, true, true); |
| return dispatchAccessibilityEvent(event); |
| } |
| |
| bool AccessibilityObject::dispatchAccessibleSetValueEvent(const String& value) const |
| { |
| if (!canSetValueAttribute()) |
| return false; |
| auto event = AccessibleSetValueEvent::create(eventNames().accessiblesetvalueEvent, value); |
| return dispatchAccessibilityEvent(event); |
| } |
| |
| // Lacking concrete evidence of orientation, horizontal means width > height. vertical is height > width; |
| AccessibilityOrientation AccessibilityObject::orientation() const |
| { |
| LayoutRect bounds = elementRect(); |
| if (bounds.size().width() > bounds.size().height()) |
| return AccessibilityOrientation::Horizontal; |
| if (bounds.size().height() > bounds.size().width()) |
| return AccessibilityOrientation::Vertical; |
| |
| return AccessibilityOrientation::Undefined; |
| } |
| |
| bool AccessibilityObject::isDescendantOfObject(const AccessibilityObject* axObject) const |
| { |
| if (!axObject || !axObject->hasChildren()) |
| return false; |
| |
| return AccessibilityObject::matchedParent(*this, false, [axObject] (const AccessibilityObject& object) { |
| return &object == axObject; |
| }) != nullptr; |
| } |
| |
| bool AccessibilityObject::isAncestorOfObject(const AccessibilityObject* axObject) const |
| { |
| if (!axObject) |
| return false; |
| |
| return this == axObject || axObject->isDescendantOfObject(this); |
| } |
| |
| AccessibilityObject* AccessibilityObject::firstAnonymousBlockChild() const |
| { |
| for (AccessibilityObject* child = firstChild(); child; child = child->nextSibling()) { |
| if (child->renderer() && child->renderer()->isAnonymousBlock()) |
| return child; |
| } |
| return nullptr; |
| } |
| |
| using ARIARoleMap = HashMap<String, AccessibilityRole, ASCIICaseInsensitiveHash>; |
| using ARIAReverseRoleMap = HashMap<AccessibilityRole, String, DefaultHash<int>::Hash, WTF::UnsignedWithZeroKeyHashTraits<int>>; |
| |
| static ARIARoleMap* gAriaRoleMap = nullptr; |
| static ARIAReverseRoleMap* gAriaReverseRoleMap = nullptr; |
| |
| struct RoleEntry { |
| String ariaRole; |
| AccessibilityRole webcoreRole; |
| }; |
| |
| static void initializeRoleMap() |
| { |
| if (gAriaRoleMap) |
| return; |
| ASSERT(!gAriaReverseRoleMap); |
| |
| const RoleEntry roles[] = { |
| { "alert", AccessibilityRole::ApplicationAlert }, |
| { "alertdialog", AccessibilityRole::ApplicationAlertDialog }, |
| { "application", AccessibilityRole::WebApplication }, |
| { "article", AccessibilityRole::DocumentArticle }, |
| { "banner", AccessibilityRole::LandmarkBanner }, |
| { "button", AccessibilityRole::Button }, |
| { "checkbox", AccessibilityRole::CheckBox }, |
| { "complementary", AccessibilityRole::LandmarkComplementary }, |
| { "contentinfo", AccessibilityRole::LandmarkContentInfo }, |
| { "dialog", AccessibilityRole::ApplicationDialog }, |
| { "directory", AccessibilityRole::Directory }, |
| // The 'doc-*' roles are defined the ARIA DPUB mobile: https://www.w3.org/TR/dpub-aam-1.0/ |
| // Editor's draft is currently at https://rawgit.com/w3c/aria/master/dpub-aam/dpub-aam.html |
| { "doc-abstract", AccessibilityRole::ApplicationTextGroup }, |
| { "doc-acknowledgments", AccessibilityRole::LandmarkDocRegion }, |
| { "doc-afterword", AccessibilityRole::LandmarkDocRegion }, |
| { "doc-appendix", AccessibilityRole::LandmarkDocRegion }, |
| { "doc-backlink", AccessibilityRole::WebCoreLink }, |
| { "doc-biblioentry", AccessibilityRole::ListItem }, |
| { "doc-bibliography", AccessibilityRole::LandmarkDocRegion }, |
| { "doc-biblioref", AccessibilityRole::WebCoreLink }, |
| { "doc-chapter", AccessibilityRole::LandmarkDocRegion }, |
| { "doc-colophon", AccessibilityRole::ApplicationTextGroup }, |
| { "doc-conclusion", AccessibilityRole::LandmarkDocRegion }, |
| { "doc-cover", AccessibilityRole::Image }, |
| { "doc-credit", AccessibilityRole::ApplicationTextGroup }, |
| { "doc-credits", AccessibilityRole::LandmarkDocRegion }, |
| { "doc-dedication", AccessibilityRole::ApplicationTextGroup }, |
| { "doc-endnote", AccessibilityRole::ListItem }, |
| { "doc-endnotes", AccessibilityRole::LandmarkDocRegion }, |
| { "doc-epigraph", AccessibilityRole::ApplicationTextGroup }, |
| { "doc-epilogue", AccessibilityRole::LandmarkDocRegion }, |
| { "doc-errata", AccessibilityRole::LandmarkDocRegion }, |
| { "doc-example", AccessibilityRole::ApplicationTextGroup }, |
| { "doc-footnote", AccessibilityRole::Footnote }, |
| { "doc-foreword", AccessibilityRole::LandmarkDocRegion }, |
| { "doc-glossary", AccessibilityRole::LandmarkDocRegion }, |
| { "doc-glossref", AccessibilityRole::WebCoreLink }, |
| { "doc-index", AccessibilityRole::LandmarkNavigation }, |
| { "doc-introduction", AccessibilityRole::LandmarkDocRegion }, |
| { "doc-noteref", AccessibilityRole::WebCoreLink }, |
| { "doc-notice", AccessibilityRole::DocumentNote }, |
| { "doc-pagebreak", AccessibilityRole::Splitter }, |
| { "doc-pagelist", AccessibilityRole::LandmarkNavigation }, |
| { "doc-part", AccessibilityRole::LandmarkDocRegion }, |
| { "doc-preface", AccessibilityRole::LandmarkDocRegion }, |
| { "doc-prologue", AccessibilityRole::LandmarkDocRegion }, |
| { "doc-pullquote", AccessibilityRole::ApplicationTextGroup }, |
| { "doc-qna", AccessibilityRole::ApplicationTextGroup }, |
| { "doc-subtitle", AccessibilityRole::Heading }, |
| { "doc-tip", AccessibilityRole::DocumentNote }, |
| { "doc-toc", AccessibilityRole::LandmarkNavigation }, |
| { "figure", AccessibilityRole::Figure }, |
| // The mappings for 'graphics-*' roles are defined in this spec: https://w3c.github.io/graphics-aam/ |
| { "graphics-document", AccessibilityRole::GraphicsDocument }, |
| { "graphics-object", AccessibilityRole::GraphicsObject }, |
| { "graphics-symbol", AccessibilityRole::GraphicsSymbol }, |
| { "grid", AccessibilityRole::Grid }, |
| { "gridcell", AccessibilityRole::GridCell }, |
| { "table", AccessibilityRole::Table }, |
| { "cell", AccessibilityRole::Cell }, |
| { "columnheader", AccessibilityRole::ColumnHeader }, |
| { "combobox", AccessibilityRole::ComboBox }, |
| { "definition", AccessibilityRole::Definition }, |
| { "document", AccessibilityRole::Document }, |
| { "feed", AccessibilityRole::Feed }, |
| { "form", AccessibilityRole::Form }, |
| { "rowheader", AccessibilityRole::RowHeader }, |
| { "group", AccessibilityRole::ApplicationGroup }, |
| { "heading", AccessibilityRole::Heading }, |
| { "img", AccessibilityRole::Image }, |
| { "link", AccessibilityRole::WebCoreLink }, |
| { "list", AccessibilityRole::List }, |
| { "listitem", AccessibilityRole::ListItem }, |
| { "listbox", AccessibilityRole::ListBox }, |
| { "log", AccessibilityRole::ApplicationLog }, |
| { "main", AccessibilityRole::LandmarkMain }, |
| { "marquee", AccessibilityRole::ApplicationMarquee }, |
| { "math", AccessibilityRole::DocumentMath }, |
| { "menu", AccessibilityRole::Menu }, |
| { "menubar", AccessibilityRole::MenuBar }, |
| { "menuitem", AccessibilityRole::MenuItem }, |
| { "menuitemcheckbox", AccessibilityRole::MenuItemCheckbox }, |
| { "menuitemradio", AccessibilityRole::MenuItemRadio }, |
| { "none", AccessibilityRole::Presentational }, |
| { "note", AccessibilityRole::DocumentNote }, |
| { "navigation", AccessibilityRole::LandmarkNavigation }, |
| { "option", AccessibilityRole::ListBoxOption }, |
| { "presentation", AccessibilityRole::Presentational }, |
| { "progressbar", AccessibilityRole::ProgressIndicator }, |
| { "radio", AccessibilityRole::RadioButton }, |
| { "radiogroup", AccessibilityRole::RadioGroup }, |
| { "region", AccessibilityRole::LandmarkRegion }, |
| { "row", AccessibilityRole::Row }, |
| { "rowgroup", AccessibilityRole::RowGroup }, |
| { "scrollbar", AccessibilityRole::ScrollBar }, |
| { "search", AccessibilityRole::LandmarkSearch }, |
| { "searchbox", AccessibilityRole::SearchField }, |
| { "separator", AccessibilityRole::Splitter }, |
| { "slider", AccessibilityRole::Slider }, |
| { "spinbutton", AccessibilityRole::SpinButton }, |
| { "status", AccessibilityRole::ApplicationStatus }, |
| { "switch", AccessibilityRole::Switch }, |
| { "tab", AccessibilityRole::Tab }, |
| { "tablist", AccessibilityRole::TabList }, |
| { "tabpanel", AccessibilityRole::TabPanel }, |
| { "text", AccessibilityRole::StaticText }, |
| { "textbox", AccessibilityRole::TextArea }, |
| { "term", AccessibilityRole::Term }, |
| { "timer", AccessibilityRole::ApplicationTimer }, |
| { "toolbar", AccessibilityRole::Toolbar }, |
| { "tooltip", AccessibilityRole::UserInterfaceTooltip }, |
| { "tree", AccessibilityRole::Tree }, |
| { "treegrid", AccessibilityRole::TreeGrid }, |
| { "treeitem", AccessibilityRole::TreeItem } |
| }; |
| |
| gAriaRoleMap = new ARIARoleMap; |
| gAriaReverseRoleMap = new ARIAReverseRoleMap; |
| size_t roleLength = WTF_ARRAY_LENGTH(roles); |
| for (size_t i = 0; i < roleLength; ++i) { |
| gAriaRoleMap->set(roles[i].ariaRole, roles[i].webcoreRole); |
| gAriaReverseRoleMap->set(static_cast<int>(roles[i].webcoreRole), roles[i].ariaRole); |
| } |
| } |
| |
| static ARIARoleMap& ariaRoleMap() |
| { |
| initializeRoleMap(); |
| return *gAriaRoleMap; |
| } |
| |
| static ARIAReverseRoleMap& reverseAriaRoleMap() |
| { |
| initializeRoleMap(); |
| return *gAriaReverseRoleMap; |
| } |
| |
| AccessibilityRole AccessibilityObject::ariaRoleToWebCoreRole(const String& value) |
| { |
| ASSERT(!value.isEmpty()); |
| for (auto roleName : StringView(value).split(' ')) { |
| AccessibilityRole role = ariaRoleMap().get<ASCIICaseInsensitiveStringViewHashTranslator>(roleName); |
| if (static_cast<int>(role)) |
| return role; |
| } |
| return AccessibilityRole::Unknown; |
| } |
| |
| String AccessibilityObject::computedRoleString() const |
| { |
| // FIXME: Need a few special cases that aren't in the RoleMap: option, etc. http://webkit.org/b/128296 |
| AccessibilityRole role = roleValue(); |
| |
| // We do not compute a role string for generic block elements with user-agent assigned roles. |
| if (role == AccessibilityRole::Group || role == AccessibilityRole::TextGroup) |
| return ""; |
| |
| // We do compute a role string for block elements with author-provided roles. |
| if (role == AccessibilityRole::ApplicationTextGroup |
| || role == AccessibilityRole::Footnote |
| || role == AccessibilityRole::GraphicsObject) |
| return reverseAriaRoleMap().get(static_cast<int>(AccessibilityRole::ApplicationGroup)); |
| |
| if (role == AccessibilityRole::GraphicsDocument) |
| return reverseAriaRoleMap().get(static_cast<int>(AccessibilityRole::Document)); |
| |
| if (role == AccessibilityRole::GraphicsSymbol) |
| return reverseAriaRoleMap().get(static_cast<int>(AccessibilityRole::Image)); |
| |
| if (role == AccessibilityRole::HorizontalRule) |
| return reverseAriaRoleMap().get(static_cast<int>(AccessibilityRole::Splitter)); |
| |
| if (role == AccessibilityRole::PopUpButton || role == AccessibilityRole::ToggleButton) |
| return reverseAriaRoleMap().get(static_cast<int>(AccessibilityRole::Button)); |
| |
| if (role == AccessibilityRole::LandmarkDocRegion) |
| return reverseAriaRoleMap().get(static_cast<int>(AccessibilityRole::LandmarkRegion)); |
| |
| return reverseAriaRoleMap().get(static_cast<int>(role)); |
| } |
| |
| bool AccessibilityObject::hasHighlighting() const |
| { |
| for (Node* node = this->node(); node; node = node->parentNode()) { |
| if (node->hasTagName(markTag)) |
| return true; |
| } |
| |
| return false; |
| } |
| |
| String AccessibilityObject::roleDescription() const |
| { |
| return stripLeadingAndTrailingHTMLSpaces(getAttribute(aria_roledescriptionAttr)); |
| } |
| |
| bool nodeHasPresentationRole(Node* node) |
| { |
| return nodeHasRole(node, "presentation") || nodeHasRole(node, "none"); |
| } |
| |
| bool AccessibilityObject::supportsPressAction() const |
| { |
| if (isButton()) |
| return true; |
| if (roleValue() == AccessibilityRole::Details) |
| return true; |
| |
| Element* actionElement = this->actionElement(); |
| if (!actionElement) |
| return false; |
| |
| // [Bug: 136247] Heuristic: element handlers that have more than one accessible descendant should not be exposed as supporting press. |
| if (actionElement != element()) { |
| if (AccessibilityObject* axObj = axObjectCache()->getOrCreate(actionElement)) { |
| AccessibilityChildrenVector results; |
| // Search within for immediate descendants that are static text. If we find more than one |
| // then this is an event delegator actionElement and we should expose the press action. |
| Vector<AccessibilitySearchKey> keys({ AccessibilitySearchKey::StaticText, AccessibilitySearchKey::Control, AccessibilitySearchKey::Graphic, AccessibilitySearchKey::Heading, AccessibilitySearchKey::Link }); |
| AccessibilitySearchCriteria criteria(axObj, AccessibilitySearchDirection::Next, emptyString(), 2, false, false); |
| criteria.searchKeys = keys; |
| axObj->findMatchingObjects(&criteria, results); |
| if (results.size() > 1) |
| return false; |
| } |
| } |
| |
| // [Bug: 133613] Heuristic: If the action element is presentational, we shouldn't expose press as a supported action. |
| return !nodeHasPresentationRole(actionElement); |
| } |
| |
| bool AccessibilityObject::supportsDatetimeAttribute() const |
| { |
| return hasTagName(insTag) || hasTagName(delTag) || hasTagName(timeTag); |
| } |
| |
| const AtomicString& AccessibilityObject::datetimeAttributeValue() const |
| { |
| return getAttribute(datetimeAttr); |
| } |
| |
| const String AccessibilityObject::keyShortcutsValue() const |
| { |
| return getAttribute(aria_keyshortcutsAttr); |
| } |
| |
| Element* AccessibilityObject::element() const |
| { |
| Node* node = this->node(); |
| if (is<Element>(node)) |
| return downcast<Element>(node); |
| return nullptr; |
| } |
| |
| bool AccessibilityObject::isValueAutofillAvailable() const |
| { |
| if (!isNativeTextControl()) |
| return false; |
| |
| Node* node = this->node(); |
| if (!is<HTMLInputElement>(node)) |
| return false; |
| |
| return downcast<HTMLInputElement>(*node).isAutoFillAvailable() || downcast<HTMLInputElement>(*node).autoFillButtonType() != AutoFillButtonType::None; |
| } |
| |
| AutoFillButtonType AccessibilityObject::valueAutofillButtonType() const |
| { |
| if (!isValueAutofillAvailable()) |
| return AutoFillButtonType::None; |
| |
| return downcast<HTMLInputElement>(*this->node()).autoFillButtonType(); |
| } |
| |
| bool AccessibilityObject::isValueAutofilled() const |
| { |
| if (!isNativeTextControl()) |
| return false; |
| |
| Node* node = this->node(); |
| if (!is<HTMLInputElement>(node)) |
| return false; |
| |
| return downcast<HTMLInputElement>(*node).isAutoFilled(); |
| } |
| |
| const String AccessibilityObject::placeholderValue() const |
| { |
| const AtomicString& placeholder = getAttribute(placeholderAttr); |
| if (!placeholder.isEmpty()) |
| return placeholder; |
| |
| const AtomicString& ariaPlaceholder = getAttribute(aria_placeholderAttr); |
| if (!ariaPlaceholder.isEmpty()) |
| return ariaPlaceholder; |
| |
| return nullAtom(); |
| } |
| |
| bool AccessibilityObject::isInsideLiveRegion(bool excludeIfOff) const |
| { |
| return liveRegionAncestor(excludeIfOff); |
| } |
| |
| AccessibilityObject* AccessibilityObject::liveRegionAncestor(bool excludeIfOff) const |
| { |
| return const_cast<AccessibilityObject*>(AccessibilityObject::matchedParent(*this, true, [excludeIfOff] (const AccessibilityObject& object) { |
| return object.supportsLiveRegion(excludeIfOff); |
| })); |
| } |
| |
| bool AccessibilityObject::supportsARIAAttributes() const |
| { |
| // This returns whether the element supports any global ARIA attributes. |
| return supportsLiveRegion() |
| || supportsARIADragging() |
| || supportsARIADropping() |
| || supportsARIAOwns() |
| || hasAttribute(aria_atomicAttr) |
| || hasAttribute(aria_busyAttr) |
| || hasAttribute(aria_controlsAttr) |
| || hasAttribute(aria_currentAttr) |
| || hasAttribute(aria_describedbyAttr) |
| || hasAttribute(aria_detailsAttr) |
| || hasAttribute(aria_disabledAttr) |
| || hasAttribute(aria_errormessageAttr) |
| || hasAttribute(aria_flowtoAttr) |
| || hasAttribute(aria_haspopupAttr) |
| || hasAttribute(aria_invalidAttr) |
| || hasAttribute(aria_labelAttr) |
| || hasAttribute(aria_labelledbyAttr) |
| || hasAttribute(aria_relevantAttr); |
| } |
| |
| bool AccessibilityObject::liveRegionStatusIsEnabled(const AtomicString& liveRegionStatus) |
| { |
| return equalLettersIgnoringASCIICase(liveRegionStatus, "polite") || equalLettersIgnoringASCIICase(liveRegionStatus, "assertive"); |
| } |
| |
| bool AccessibilityObject::supportsLiveRegion(bool excludeIfOff) const |
| { |
| const AtomicString& liveRegionStatusValue = liveRegionStatus(); |
| return excludeIfOff ? liveRegionStatusIsEnabled(liveRegionStatusValue) : !liveRegionStatusValue.isEmpty(); |
| } |
| |
| AccessibilityObject* AccessibilityObject::elementAccessibilityHitTest(const IntPoint& point) const |
| { |
| // Send the hit test back into the sub-frame if necessary. |
| if (isAttachment()) { |
| Widget* widget = widgetForAttachmentView(); |
| // Normalize the point for the widget's bounds. |
| if (widget && widget->isFrameView()) { |
| if (AXObjectCache* cache = axObjectCache()) |
| return cache->getOrCreate(widget)->accessibilityHitTest(IntPoint(point - widget->frameRect().location())); |
| } |
| } |
| |
| // Check if there are any mock elements that need to be handled. |
| for (const auto& child : m_children) { |
| if (child->isMockObject() && child->elementRect().contains(point)) |
| return child->elementAccessibilityHitTest(point); |
| } |
| |
| return const_cast<AccessibilityObject*>(this); |
| } |
| |
| AXObjectCache* AccessibilityObject::axObjectCache() const |
| { |
| Document* doc = document(); |
| if (doc) |
| return doc->axObjectCache(); |
| return nullptr; |
| } |
| |
| AccessibilityObject* AccessibilityObject::focusedUIElement() const |
| { |
| Document* doc = document(); |
| if (!doc) |
| return nullptr; |
| |
| Page* page = doc->page(); |
| if (!page) |
| return nullptr; |
| |
| return AXObjectCache::focusedUIElementForPage(page); |
| } |
| |
| AccessibilitySortDirection AccessibilityObject::sortDirection() const |
| { |
| AccessibilityRole role = roleValue(); |
| if (role != AccessibilityRole::RowHeader && role != AccessibilityRole::ColumnHeader) |
| return AccessibilitySortDirection::Invalid; |
| |
| const AtomicString& sortAttribute = getAttribute(aria_sortAttr); |
| if (equalLettersIgnoringASCIICase(sortAttribute, "ascending")) |
| return AccessibilitySortDirection::Ascending; |
| if (equalLettersIgnoringASCIICase(sortAttribute, "descending")) |
| return AccessibilitySortDirection::Descending; |
| if (equalLettersIgnoringASCIICase(sortAttribute, "other")) |
| return AccessibilitySortDirection::Other; |
| |
| return AccessibilitySortDirection::None; |
| } |
| |
| bool AccessibilityObject::supportsRangeValue() const |
| { |
| return isProgressIndicator() |
| || isSlider() |
| || isScrollbar() |
| || isSpinButton() |
| || (isSplitter() && canSetFocusAttribute()) |
| || isAttachmentElement(); |
| } |
| |
| bool AccessibilityObject::supportsHasPopup() const |
| { |
| return hasAttribute(aria_haspopupAttr) || isComboBox(); |
| } |
| |
| String AccessibilityObject::hasPopupValue() const |
| { |
| const AtomicString& hasPopup = getAttribute(aria_haspopupAttr); |
| if (equalLettersIgnoringASCIICase(hasPopup, "true") |
| || equalLettersIgnoringASCIICase(hasPopup, "dialog") |
| || equalLettersIgnoringASCIICase(hasPopup, "grid") |
| || equalLettersIgnoringASCIICase(hasPopup, "listbox") |
| || equalLettersIgnoringASCIICase(hasPopup, "menu") |
| || equalLettersIgnoringASCIICase(hasPopup, "tree")) |
| return hasPopup; |
| |
| // In ARIA 1.1, the implicit value for combobox became "listbox." |
| if (isComboBox() && hasPopup.isEmpty()) |
| return "listbox"; |
| |
| // The spec states that "User agents must treat any value of aria-haspopup that is not |
| // included in the list of allowed values, including an empty string, as if the value |
| // false had been provided." |
| return "false"; |
| } |
| |
| bool AccessibilityObject::supportsSetSize() const |
| { |
| return hasAttribute(aria_setsizeAttr); |
| } |
| |
| bool AccessibilityObject::supportsPosInSet() const |
| { |
| return hasAttribute(aria_posinsetAttr); |
| } |
| |
| int AccessibilityObject::setSize() const |
| { |
| return getAttribute(aria_setsizeAttr).toInt(); |
| } |
| |
| int AccessibilityObject::posInSet() const |
| { |
| return getAttribute(aria_posinsetAttr).toInt(); |
| } |
| |
| const AtomicString& AccessibilityObject::identifierAttribute() const |
| { |
| return getAttribute(idAttr); |
| } |
| |
| void AccessibilityObject::classList(Vector<String>& classList) const |
| { |
| Node* node = this->node(); |
| if (!is<Element>(node)) |
| return; |
| |
| Element* element = downcast<Element>(node); |
| DOMTokenList& list = element->classList(); |
| unsigned length = list.length(); |
| for (unsigned k = 0; k < length; k++) |
| classList.append(list.item(k).string()); |
| } |
| |
| bool AccessibilityObject::supportsPressed() const |
| { |
| const AtomicString& expanded = getAttribute(aria_pressedAttr); |
| return equalLettersIgnoringASCIICase(expanded, "true") || equalLettersIgnoringASCIICase(expanded, "false"); |
| } |
| |
| bool AccessibilityObject::supportsExpanded() const |
| { |
| // Undefined values should not result in this attribute being exposed to ATs according to ARIA. |
| const AtomicString& expanded = getAttribute(aria_expandedAttr); |
| if (equalLettersIgnoringASCIICase(expanded, "true") || equalLettersIgnoringASCIICase(expanded, "false")) |
| return true; |
| switch (roleValue()) { |
| case AccessibilityRole::ComboBox: |
| case AccessibilityRole::DisclosureTriangle: |
| case AccessibilityRole::Details: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool AccessibilityObject::isExpanded() const |
| { |
| if (equalLettersIgnoringASCIICase(getAttribute(aria_expandedAttr), "true")) |
| return true; |
| |
| if (is<HTMLDetailsElement>(node())) |
| return downcast<HTMLDetailsElement>(node())->isOpen(); |
| |
| // Summary element should use its details parent's expanded status. |
| if (isSummary()) { |
| if (const AccessibilityObject* parent = AccessibilityObject::matchedParent(*this, false, [] (const AccessibilityObject& object) { |
| return object.roleValue() == AccessibilityRole::Details; |
| })) |
| return parent->isExpanded(); |
| } |
| |
| return false; |
| } |
| |
| bool AccessibilityObject::supportsChecked() const |
| { |
| switch (roleValue()) { |
| case AccessibilityRole::CheckBox: |
| case AccessibilityRole::MenuItemCheckbox: |
| case AccessibilityRole::MenuItemRadio: |
| case AccessibilityRole::RadioButton: |
| case AccessibilityRole::Switch: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| AccessibilityButtonState AccessibilityObject::checkboxOrRadioValue() const |
| { |
| // If this is a real checkbox or radio button, AccessibilityRenderObject will handle. |
| // If it's an ARIA checkbox, radio, or switch the aria-checked attribute should be used. |
| // If it's a toggle button, the aria-pressed attribute is consulted. |
| |
| if (isToggleButton()) { |
| const AtomicString& ariaPressed = getAttribute(aria_pressedAttr); |
| if (equalLettersIgnoringASCIICase(ariaPressed, "true")) |
| return AccessibilityButtonState::On; |
| if (equalLettersIgnoringASCIICase(ariaPressed, "mixed")) |
| return AccessibilityButtonState::Mixed; |
| return AccessibilityButtonState::Off; |
| } |
| |
| const AtomicString& result = getAttribute(aria_checkedAttr); |
| if (equalLettersIgnoringASCIICase(result, "true")) |
| return AccessibilityButtonState::On; |
| if (equalLettersIgnoringASCIICase(result, "mixed")) { |
| // ARIA says that radio, menuitemradio, and switch elements must NOT expose button state mixed. |
| AccessibilityRole ariaRole = ariaRoleAttribute(); |
| if (ariaRole == AccessibilityRole::RadioButton || ariaRole == AccessibilityRole::MenuItemRadio || ariaRole == AccessibilityRole::Switch) |
| return AccessibilityButtonState::Off; |
| return AccessibilityButtonState::Mixed; |
| } |
| |
| if (isIndeterminate()) |
| return AccessibilityButtonState::Mixed; |
| |
| return AccessibilityButtonState::Off; |
| } |
| |
| // This is a 1-dimensional scroll offset helper function that's applied |
| // separately in the horizontal and vertical directions, because the |
| // logic is the same. The goal is to compute the best scroll offset |
| // in order to make an object visible within a viewport. |
| // |
| // If the object is already fully visible, returns the same scroll |
| // offset. |
| // |
| // In case the whole object cannot fit, you can specify a |
| // subfocus - a smaller region within the object that should |
| // be prioritized. If the whole object can fit, the subfocus is |
| // ignored. |
| // |
| // If possible, the object and subfocus are centered within the |
| // viewport. |
| // |
| // Example 1: the object is already visible, so nothing happens. |
| // +----------Viewport---------+ |
| // +---Object---+ |
| // +--SubFocus--+ |
| // |
| // Example 2: the object is not fully visible, so it's centered |
| // within the viewport. |
| // Before: |
| // +----------Viewport---------+ |
| // +---Object---+ |
| // +--SubFocus--+ |
| // |
| // After: |
| // +----------Viewport---------+ |
| // +---Object---+ |
| // +--SubFocus--+ |
| // |
| // Example 3: the object is larger than the viewport, so the |
| // viewport moves to show as much of the object as possible, |
| // while also trying to center the subfocus. |
| // Before: |
| // +----------Viewport---------+ |
| // +---------------Object--------------+ |
| // +-SubFocus-+ |
| // |
| // After: |
| // +----------Viewport---------+ |
| // +---------------Object--------------+ |
| // +-SubFocus-+ |
| // |
| // When constraints cannot be fully satisfied, the min |
| // (left/top) position takes precedence over the max (right/bottom). |
| // |
| // Note that the return value represents the ideal new scroll offset. |
| // This may be out of range - the calling function should clip this |
| // to the available range. |
| static int computeBestScrollOffset(int currentScrollOffset, int subfocusMin, int subfocusMax, int objectMin, int objectMax, int viewportMin, int viewportMax) |
| { |
| int viewportSize = viewportMax - viewportMin; |
| |
| // If the object size is larger than the viewport size, consider |
| // only a portion that's as large as the viewport, centering on |
| // the subfocus as much as possible. |
| if (objectMax - objectMin > viewportSize) { |
| // Since it's impossible to fit the whole object in the |
| // viewport, exit now if the subfocus is already within the viewport. |
| if (subfocusMin - currentScrollOffset >= viewportMin && subfocusMax - currentScrollOffset <= viewportMax) |
| return currentScrollOffset; |
| |
| // Subfocus must be within focus. |
| subfocusMin = std::max(subfocusMin, objectMin); |
| subfocusMax = std::min(subfocusMax, objectMax); |
| |
| // Subfocus must be no larger than the viewport size; favor top/left. |
| if (subfocusMax - subfocusMin > viewportSize) |
| subfocusMax = subfocusMin + viewportSize; |
| |
| // Compute the size of an object centered on the subfocus, the size of the viewport. |
| int centeredObjectMin = (subfocusMin + subfocusMax - viewportSize) / 2; |
| int centeredObjectMax = centeredObjectMin + viewportSize; |
| |
| objectMin = std::max(objectMin, centeredObjectMin); |
| objectMax = std::min(objectMax, centeredObjectMax); |
| } |
| |
| // Exit now if the focus is already within the viewport. |
| if (objectMin - currentScrollOffset >= viewportMin |
| && objectMax - currentScrollOffset <= viewportMax) |
| return currentScrollOffset; |
| |
| // Center the object in the viewport. |
| return (objectMin + objectMax - viewportMin - viewportMax) / 2; |
| } |
| |
| bool AccessibilityObject::isOnscreen() const |
| { |
| bool isOnscreen = true; |
| |
| // To figure out if the element is onscreen, we start by building of a stack starting with the |
| // element, and then include every scrollable parent in the hierarchy. |
| Vector<const AccessibilityObject*> objects; |
| |
| objects.append(this); |
| for (AccessibilityObject* parentObject = this->parentObject(); parentObject; parentObject = parentObject->parentObject()) { |
| if (parentObject->getScrollableAreaIfScrollable()) |
| objects.append(parentObject); |
| } |
| |
| // Now, go back through that chain and make sure each inner object is within the |
| // visible bounds of the outer object. |
| size_t levels = objects.size() - 1; |
| |
| for (size_t i = levels; i >= 1; i--) { |
| const AccessibilityObject* outer = objects[i]; |
| const AccessibilityObject* inner = objects[i - 1]; |
| // FIXME: unclear if we need LegacyIOSDocumentVisibleRect. |
| const IntRect outerRect = i < levels ? snappedIntRect(outer->boundingBoxRect()) : outer->getScrollableAreaIfScrollable()->visibleContentRect(ScrollableArea::LegacyIOSDocumentVisibleRect); |
| const IntRect innerRect = snappedIntRect(inner->isAccessibilityScrollView() ? inner->parentObject()->boundingBoxRect() : inner->boundingBoxRect()); |
| |
| if (!outerRect.intersects(innerRect)) { |
| isOnscreen = false; |
| break; |
| } |
| } |
| |
| return isOnscreen; |
| } |
| |
| void AccessibilityObject::scrollToMakeVisible() const |
| { |
| if (dispatchAccessibilityEventWithType(AccessibilityEventType::ScrollIntoView)) |
| return; |
| IntRect objectRect = snappedIntRect(boundingBoxRect()); |
| objectRect.setLocation(IntPoint()); |
| scrollToMakeVisibleWithSubFocus(objectRect); |
| } |
| |
| void AccessibilityObject::scrollToMakeVisibleWithSubFocus(const IntRect& subfocus) const |
| { |
| // Search up the parent chain until we find the first one that's scrollable. |
| AccessibilityObject* scrollParent = parentObject(); |
| ScrollableArea* scrollableArea; |
| for (scrollableArea = nullptr; |
| scrollParent && !(scrollableArea = scrollParent->getScrollableAreaIfScrollable()); |
| scrollParent = scrollParent->parentObject()) { } |
| if (!scrollableArea) |
| return; |
| |
| LayoutRect objectRect = boundingBoxRect(); |
| IntPoint scrollPosition = scrollableArea->scrollPosition(); |
| // FIXME: unclear if we need LegacyIOSDocumentVisibleRect. |
| IntRect scrollVisibleRect = scrollableArea->visibleContentRect(ScrollableArea::LegacyIOSDocumentVisibleRect); |
| |
| if (!scrollParent->isScrollView()) { |
| objectRect.moveBy(scrollPosition); |
| objectRect.moveBy(-snappedIntRect(scrollParent->elementRect()).location()); |
| } |
| |
| int desiredX = computeBestScrollOffset( |
| scrollPosition.x(), |
| objectRect.x() + subfocus.x(), objectRect.x() + subfocus.maxX(), |
| objectRect.x(), objectRect.maxX(), |
| 0, scrollVisibleRect.width()); |
| int desiredY = computeBestScrollOffset( |
| scrollPosition.y(), |
| objectRect.y() + subfocus.y(), objectRect.y() + subfocus.maxY(), |
| objectRect.y(), objectRect.maxY(), |
| 0, scrollVisibleRect.height()); |
| |
| scrollParent->scrollTo(IntPoint(desiredX, desiredY)); |
| |
| // Convert the subfocus into the coordinates of the scroll parent. |
| IntRect newSubfocus = subfocus; |
| IntRect newElementRect = snappedIntRect(elementRect()); |
| IntRect scrollParentRect = snappedIntRect(scrollParent->elementRect()); |
| newSubfocus.move(newElementRect.x(), newElementRect.y()); |
| newSubfocus.move(-scrollParentRect.x(), -scrollParentRect.y()); |
| |
| // Recursively make sure the scroll parent itself is visible. |
| if (scrollParent->parentObject()) |
| scrollParent->scrollToMakeVisibleWithSubFocus(newSubfocus); |
| } |
| |
| void AccessibilityObject::scrollToGlobalPoint(const IntPoint& globalPoint) const |
| { |
| // Search up the parent chain and create a vector of all scrollable parent objects |
| // and ending with this object itself. |
| Vector<const AccessibilityObject*> objects; |
| |
| objects.append(this); |
| for (AccessibilityObject* parentObject = this->parentObject(); parentObject; parentObject = parentObject->parentObject()) { |
| if (parentObject->getScrollableAreaIfScrollable()) |
| objects.append(parentObject); |
| } |
| |
| objects.reverse(); |
| |
| // Start with the outermost scrollable (the main window) and try to scroll the |
| // next innermost object to the given point. |
| int offsetX = 0, offsetY = 0; |
| IntPoint point = globalPoint; |
| size_t levels = objects.size() - 1; |
| for (size_t i = 0; i < levels; i++) { |
| const AccessibilityObject* outer = objects[i]; |
| const AccessibilityObject* inner = objects[i + 1]; |
| |
| ScrollableArea* scrollableArea = outer->getScrollableAreaIfScrollable(); |
| |
| LayoutRect innerRect = inner->isAccessibilityScrollView() ? inner->parentObject()->boundingBoxRect() : inner->boundingBoxRect(); |
| LayoutRect objectRect = innerRect; |
| IntPoint scrollPosition = scrollableArea->scrollPosition(); |
| |
| // Convert the object rect into local coordinates. |
| objectRect.move(offsetX, offsetY); |
| if (!outer->isAccessibilityScrollView()) |
| objectRect.move(scrollPosition.x(), scrollPosition.y()); |
| |
| int desiredX = computeBestScrollOffset( |
| 0, |
| objectRect.x(), objectRect.maxX(), |
| objectRect.x(), objectRect.maxX(), |
| point.x(), point.x()); |
| int desiredY = computeBestScrollOffset( |
| 0, |
| objectRect.y(), objectRect.maxY(), |
| objectRect.y(), objectRect.maxY(), |
| point.y(), point.y()); |
| outer->scrollTo(IntPoint(desiredX, desiredY)); |
| |
| if (outer->isAccessibilityScrollView() && !inner->isAccessibilityScrollView()) { |
| // If outer object we just scrolled is a scroll view (main window or iframe) but the |
| // inner object is not, keep track of the coordinate transformation to apply to |
| // future nested calculations. |
| scrollPosition = scrollableArea->scrollPosition(); |
| offsetX -= (scrollPosition.x() + point.x()); |
| offsetY -= (scrollPosition.y() + point.y()); |
| point.move(scrollPosition.x() - innerRect.x(), |
| scrollPosition.y() - innerRect.y()); |
| } else if (inner->isAccessibilityScrollView()) { |
| // Otherwise, if the inner object is a scroll view, reset the coordinate transformation. |
| offsetX = 0; |
| offsetY = 0; |
| } |
| } |
| } |
| |
| void AccessibilityObject::scrollAreaAndAncestor(std::pair<ScrollableArea*, AccessibilityObject*>& scrollers) const |
| { |
| // Search up the parent chain until we find the first one that's scrollable. |
| scrollers.first = nullptr; |
| for (scrollers.second = parentObject(); scrollers.second; scrollers.second = scrollers.second->parentObject()) { |
| if ((scrollers.first = scrollers.second->getScrollableAreaIfScrollable())) |
| break; |
| } |
| } |
| |
| ScrollableArea* AccessibilityObject::scrollableAreaAncestor() const |
| { |
| std::pair<ScrollableArea*, AccessibilityObject*> scrollers; |
| scrollAreaAndAncestor(scrollers); |
| return scrollers.first; |
| } |
| |
| IntPoint AccessibilityObject::scrollPosition() const |
| { |
| if (auto scroller = scrollableAreaAncestor()) |
| return scroller->scrollPosition(); |
| |
| return IntPoint(); |
| } |
| |
| IntRect AccessibilityObject::scrollVisibleContentRect() const |
| { |
| if (auto scroller = scrollableAreaAncestor()) |
| return scroller->visibleContentRect(ScrollableArea::LegacyIOSDocumentVisibleRect); |
| |
| return IntRect(); |
| } |
| |
| IntSize AccessibilityObject::scrollContentsSize() const |
| { |
| if (auto scroller = scrollableAreaAncestor()) |
| return scroller->contentsSize(); |
| |
| return IntSize(); |
| } |
| |
| bool AccessibilityObject::scrollByPage(ScrollByPageDirection direction) const |
| { |
| std::pair<ScrollableArea*, AccessibilityObject*> scrollers; |
| scrollAreaAndAncestor(scrollers); |
| ScrollableArea* scrollableArea = scrollers.first; |
| AccessibilityObject* scrollParent = scrollers.second; |
| |
| if (!scrollableArea) |
| return false; |
| |
| IntPoint scrollPosition = scrollableArea->scrollPosition(); |
| IntPoint newScrollPosition = scrollPosition; |
| IntSize scrollSize = scrollableArea->contentsSize(); |
| IntRect scrollVisibleRect = scrollableArea->visibleContentRect(ScrollableArea::LegacyIOSDocumentVisibleRect); |
| switch (direction) { |
| case ScrollByPageDirection::Right: { |
| int scrollAmount = scrollVisibleRect.size().width(); |
| int newX = scrollPosition.x() - scrollAmount; |
| newScrollPosition.setX(std::max(newX, 0)); |
| break; |
| } |
| case ScrollByPageDirection::Left: { |
| int scrollAmount = scrollVisibleRect.size().width(); |
| int newX = scrollAmount + scrollPosition.x(); |
| int maxX = scrollSize.width() - scrollAmount; |
| newScrollPosition.setX(std::min(newX, maxX)); |
| break; |
| } |
| case ScrollByPageDirection::Up: { |
| int scrollAmount = scrollVisibleRect.size().height(); |
| int newY = scrollPosition.y() - scrollAmount; |
| newScrollPosition.setY(std::max(newY, 0)); |
| break; |
| } |
| case ScrollByPageDirection::Down: { |
| int scrollAmount = scrollVisibleRect.size().height(); |
| int newY = scrollAmount + scrollPosition.y(); |
| int maxY = scrollSize.height() - scrollAmount; |
| newScrollPosition.setY(std::min(newY, maxY)); |
| break; |
| } |
| } |
| |
| if (newScrollPosition != scrollPosition) { |
| scrollParent->scrollTo(newScrollPosition); |
| document()->updateLayoutIgnorePendingStylesheets(); |
| return true; |
| } |
| |
| return false; |
| } |
| |
| |
| bool AccessibilityObject::lastKnownIsIgnoredValue() |
| { |
| if (m_lastKnownIsIgnoredValue == AccessibilityObjectInclusion::DefaultBehavior) |
| m_lastKnownIsIgnoredValue = accessibilityIsIgnored() ? AccessibilityObjectInclusion::IgnoreObject : AccessibilityObjectInclusion::IncludeObject; |
| |
| return m_lastKnownIsIgnoredValue == AccessibilityObjectInclusion::IgnoreObject; |
| } |
| |
| void AccessibilityObject::setLastKnownIsIgnoredValue(bool isIgnored) |
| { |
| m_lastKnownIsIgnoredValue = isIgnored ? AccessibilityObjectInclusion::IgnoreObject : AccessibilityObjectInclusion::IncludeObject; |
| } |
| |
| void AccessibilityObject::notifyIfIgnoredValueChanged() |
| { |
| bool isIgnored = accessibilityIsIgnored(); |
| if (lastKnownIsIgnoredValue() != isIgnored) { |
| if (AXObjectCache* cache = axObjectCache()) |
| cache->childrenChanged(parentObject()); |
| setLastKnownIsIgnoredValue(isIgnored); |
| } |
| } |
| |
| bool AccessibilityObject::pressedIsPresent() const |
| { |
| return !getAttribute(aria_pressedAttr).isEmpty(); |
| } |
| |
| TextIteratorBehavior AccessibilityObject::textIteratorBehaviorForTextRange() const |
| { |
| TextIteratorBehavior behavior = TextIteratorIgnoresStyleVisibility; |
| |
| #if PLATFORM(GTK) |
| // We need to emit replaced elements for GTK, and present |
| // them with the 'object replacement character' (0xFFFC). |
| behavior = static_cast<TextIteratorBehavior>(behavior | TextIteratorEmitsObjectReplacementCharacters); |
| #endif |
| |
| return behavior; |
| } |
| |
| AccessibilityRole AccessibilityObject::buttonRoleType() const |
| { |
| // If aria-pressed is present, then it should be exposed as a toggle button. |
| // http://www.w3.org/TR/wai-aria/states_and_properties#aria-pressed |
| if (pressedIsPresent()) |
| return AccessibilityRole::ToggleButton; |
| if (hasPopup()) |
| return AccessibilityRole::PopUpButton; |
| // We don't contemplate AccessibilityRole::RadioButton, as it depends on the input |
| // type. |
| |
| return AccessibilityRole::Button; |
| } |
| |
| bool AccessibilityObject::isButton() const |
| { |
| AccessibilityRole role = roleValue(); |
| |
| return role == AccessibilityRole::Button || role == AccessibilityRole::PopUpButton || role == AccessibilityRole::ToggleButton; |
| } |
| |
| bool AccessibilityObject::accessibilityIsIgnoredByDefault() const |
| { |
| return defaultObjectInclusion() == AccessibilityObjectInclusion::IgnoreObject; |
| } |
| |
| // ARIA component of hidden definition. |
| // http://www.w3.org/TR/wai-aria/terms#def_hidden |
| bool AccessibilityObject::isAXHidden() const |
| { |
| return AccessibilityObject::matchedParent(*this, true, [] (const AccessibilityObject& object) { |
| return equalLettersIgnoringASCIICase(object.getAttribute(aria_hiddenAttr), "true"); |
| }) != nullptr; |
| } |
| |
| // DOM component of hidden definition. |
| // http://www.w3.org/TR/wai-aria/terms#def_hidden |
| bool AccessibilityObject::isDOMHidden() const |
| { |
| RenderObject* renderer = this->renderer(); |
| if (!renderer) |
| return true; |
| |
| const RenderStyle& style = renderer->style(); |
| return style.display() == NONE || style.visibility() != VISIBLE; |
| } |
| |
| bool AccessibilityObject::isShowingValidationMessage() const |
| { |
| if (is<HTMLFormControlElement>(node())) |
| return downcast<HTMLFormControlElement>(*node()).isShowingValidationMessage(); |
| return false; |
| } |
| |
| String AccessibilityObject::validationMessage() const |
| { |
| if (is<HTMLFormControlElement>(node())) |
| return downcast<HTMLFormControlElement>(*node()).validationMessage(); |
| return String(); |
| } |
| |
| AccessibilityObjectInclusion AccessibilityObject::defaultObjectInclusion() const |
| { |
| bool useParentData = !m_isIgnoredFromParentData.isNull(); |
| |
| if (useParentData ? m_isIgnoredFromParentData.isAXHidden : isAXHidden()) |
| return AccessibilityObjectInclusion::IgnoreObject; |
| |
| if (ignoredFromModalPresence()) |
| return AccessibilityObjectInclusion::IgnoreObject; |
| |
| if (useParentData ? m_isIgnoredFromParentData.isPresentationalChildOfAriaRole : isPresentationalChildOfAriaRole()) |
| return AccessibilityObjectInclusion::IgnoreObject; |
| |
| return accessibilityPlatformIncludesObject(); |
| } |
| |
| bool AccessibilityObject::accessibilityIsIgnored() const |
| { |
| AXComputedObjectAttributeCache* attributeCache = nullptr; |
| AXObjectCache* cache = axObjectCache(); |
| if (cache) |
| attributeCache = cache->computedObjectAttributeCache(); |
| |
| if (attributeCache) { |
| AccessibilityObjectInclusion ignored = attributeCache->getIgnored(axObjectID()); |
| switch (ignored) { |
| case AccessibilityObjectInclusion::IgnoreObject: |
| return true; |
| case AccessibilityObjectInclusion::IncludeObject: |
| return false; |
| case AccessibilityObjectInclusion::DefaultBehavior: |
| break; |
| } |
| } |
| |
| bool result = computeAccessibilityIsIgnored(); |
| |
| // In case computing axIsIgnored disables attribute caching, we should refetch the object to see if it exists. |
| if (cache && (attributeCache = cache->computedObjectAttributeCache())) |
| attributeCache->setIgnored(axObjectID(), result ? AccessibilityObjectInclusion::IgnoreObject : AccessibilityObjectInclusion::IncludeObject); |
| |
| return result; |
| } |
| |
| void AccessibilityObject::elementsFromAttribute(Vector<Element*>& elements, const QualifiedName& attribute) const |
| { |
| Node* node = this->node(); |
| if (!node || !node->isElementNode()) |
| return; |
| |
| TreeScope& treeScope = node->treeScope(); |
| |
| const AtomicString& idList = getAttribute(attribute); |
| if (idList.isEmpty()) |
| return; |
| |
| auto spaceSplitString = SpaceSplitString(idList, false); |
| size_t length = spaceSplitString.size(); |
| for (size_t i = 0; i < length; ++i) { |
| if (auto* idElement = treeScope.getElementById(spaceSplitString[i])) |
| elements.append(idElement); |
| } |
| } |
| |
| #if PLATFORM(COCOA) |
| bool AccessibilityObject::preventKeyboardDOMEventDispatch() const |
| { |
| Frame* frame = this->frame(); |
| return frame && frame->settings().preventKeyboardDOMEventDispatch(); |
| } |
| |
| void AccessibilityObject::setPreventKeyboardDOMEventDispatch(bool on) |
| { |
| Frame* frame = this->frame(); |
| if (!frame) |
| return; |
| frame->settings().setPreventKeyboardDOMEventDispatch(on); |
| } |
| #endif |
| |
| AccessibilityObject* AccessibilityObject::focusableAncestor() |
| { |
| return const_cast<AccessibilityObject*>(AccessibilityObject::matchedParent(*this, true, [] (const AccessibilityObject& object) { |
| return object.canSetFocusAttribute(); |
| })); |
| } |
| |
| AccessibilityObject* AccessibilityObject::editableAncestor() |
| { |
| return const_cast<AccessibilityObject*>(AccessibilityObject::matchedParent(*this, true, [] (const AccessibilityObject& object) { |
| return object.isTextControl(); |
| })); |
| } |
| |
| AccessibilityObject* AccessibilityObject::highestEditableAncestor() |
| { |
| AccessibilityObject* editableAncestor = this->editableAncestor(); |
| AccessibilityObject* previousEditableAncestor = nullptr; |
| while (editableAncestor) { |
| if (editableAncestor == previousEditableAncestor) { |
| if (AccessibilityObject* parent = editableAncestor->parentObject()) { |
| editableAncestor = parent->editableAncestor(); |
| continue; |
| } |
| break; |
| } |
| previousEditableAncestor = editableAncestor; |
| editableAncestor = editableAncestor->editableAncestor(); |
| } |
| return previousEditableAncestor; |
| } |
| |
| AccessibilityObject* AccessibilityObject::radioGroupAncestor() const |
| { |
| return const_cast<AccessibilityObject*>(AccessibilityObject::matchedParent(*this, false, [] (const AccessibilityObject& object) { |
| return object.isRadioGroup(); |
| })); |
| } |
| |
| bool AccessibilityObject::isStyleFormatGroup() const |
| { |
| Node* node = this->node(); |
| if (!node) |
| return false; |
| |
| return node->hasTagName(kbdTag) || node->hasTagName(codeTag) |
| || node->hasTagName(preTag) || node->hasTagName(sampTag) |
| || node->hasTagName(varTag) || node->hasTagName(citeTag) |
| || node->hasTagName(insTag) || node->hasTagName(delTag) |
| || node->hasTagName(supTag) || node->hasTagName(subTag); |
| } |
| |
| bool AccessibilityObject::isSubscriptStyleGroup() const |
| { |
| Node* node = this->node(); |
| return node && node->hasTagName(subTag); |
| } |
| |
| bool AccessibilityObject::isSuperscriptStyleGroup() const |
| { |
| Node* node = this->node(); |
| return node && node->hasTagName(supTag); |
| } |
| |
| bool AccessibilityObject::isFigureElement() const |
| { |
| Node* node = this->node(); |
| return node && node->hasTagName(figureTag); |
| } |
| |
| bool AccessibilityObject::isOutput() const |
| { |
| Node* node = this->node(); |
| return node && node->hasTagName(outputTag); |
| } |
| |
| bool AccessibilityObject::isContainedByPasswordField() const |
| { |
| Node* node = this->node(); |
| if (!node) |
| return false; |
| |
| if (ariaRoleAttribute() != AccessibilityRole::Unknown) |
| return false; |
| |
| Element* element = node->shadowHost(); |
| return is<HTMLInputElement>(element) && downcast<HTMLInputElement>(*element).isPasswordField(); |
| } |
| |
| AccessibilityObject* AccessibilityObject::selectedListItem() |
| { |
| for (const auto& child : children()) { |
| if (child->isListItem() && (child->isSelected() || child->isActiveDescendantOfFocusedContainer())) |
| return child.get(); |
| } |
| |
| return nullptr; |
| } |
| |
| void AccessibilityObject::ariaElementsFromAttribute(AccessibilityChildrenVector& children, const QualifiedName& attributeName) const |
| { |
| Vector<Element*> elements; |
| elementsFromAttribute(elements, attributeName); |
| AXObjectCache* cache = axObjectCache(); |
| for (const auto& element : elements) { |
| if (AccessibilityObject* axObject = cache->getOrCreate(element)) |
| children.append(axObject); |
| } |
| } |
| |
| void AccessibilityObject::ariaElementsReferencedByAttribute(AccessibilityChildrenVector& elements, const QualifiedName& attribute) const |
| { |
| auto id = identifierAttribute(); |
| if (id.isEmpty()) |
| return; |
| |
| AXObjectCache* cache = axObjectCache(); |
| if (!cache) |
| return; |
| |
| for (auto& element : descendantsOfType<Element>(node()->treeScope().rootNode())) { |
| const AtomicString& idList = element.attributeWithoutSynchronization(attribute); |
| if (!SpaceSplitString(idList, false).contains(id)) |
| continue; |
| |
| if (AccessibilityObject* axObject = cache->getOrCreate(&element)) |
| elements.append(axObject); |
| } |
| } |
| |
| bool AccessibilityObject::isActiveDescendantOfFocusedContainer() const |
| { |
| AccessibilityChildrenVector containers; |
| ariaActiveDescendantReferencingElements(containers); |
| for (auto& container : containers) { |
| if (container->isFocused()) |
| return true; |
| } |
| |
| return false; |
| } |
| |
| void AccessibilityObject::ariaActiveDescendantReferencingElements(AccessibilityChildrenVector& containers) const |
| { |
| ariaElementsReferencedByAttribute(containers, aria_activedescendantAttr); |
| } |
| |
| void AccessibilityObject::ariaControlsElements(AccessibilityChildrenVector& ariaControls) const |
| { |
| ariaElementsFromAttribute(ariaControls, aria_controlsAttr); |
| } |
| |
| void AccessibilityObject::ariaControlsReferencingElements(AccessibilityChildrenVector& controllers) const |
| { |
| ariaElementsReferencedByAttribute(controllers, aria_controlsAttr); |
| } |
| |
| void AccessibilityObject::ariaDescribedByElements(AccessibilityChildrenVector& ariaDescribedBy) const |
| { |
| ariaElementsFromAttribute(ariaDescribedBy, aria_describedbyAttr); |
| } |
| |
| void AccessibilityObject::ariaDescribedByReferencingElements(AccessibilityChildrenVector& describers) const |
| { |
| ariaElementsReferencedByAttribute(describers, aria_describedbyAttr); |
| } |
| |
| void AccessibilityObject::ariaDetailsElements(AccessibilityChildrenVector& ariaDetails) const |
| { |
| ariaElementsFromAttribute(ariaDetails, aria_detailsAttr); |
| } |
| |
| void AccessibilityObject::ariaDetailsReferencingElements(AccessibilityChildrenVector& detailsFor) const |
| { |
| ariaElementsReferencedByAttribute(detailsFor, aria_detailsAttr); |
| } |
| |
| void AccessibilityObject::ariaErrorMessageElements(AccessibilityChildrenVector& ariaErrorMessage) const |
| { |
| ariaElementsFromAttribute(ariaErrorMessage, aria_errormessageAttr); |
| } |
| |
| void AccessibilityObject::ariaErrorMessageReferencingElements(AccessibilityChildrenVector& errorMessageFor) const |
| { |
| ariaElementsReferencedByAttribute(errorMessageFor, aria_errormessageAttr); |
| } |
| |
| void AccessibilityObject::ariaFlowToElements(AccessibilityChildrenVector& flowTo) const |
| { |
| ariaElementsFromAttribute(flowTo, aria_flowtoAttr); |
| } |
| |
| void AccessibilityObject::ariaFlowToReferencingElements(AccessibilityChildrenVector& flowFrom) const |
| { |
| ariaElementsReferencedByAttribute(flowFrom, aria_flowtoAttr); |
| } |
| |
| void AccessibilityObject::ariaLabelledByElements(AccessibilityChildrenVector& ariaLabelledBy) const |
| { |
| ariaElementsFromAttribute(ariaLabelledBy, aria_labelledbyAttr); |
| if (!ariaLabelledBy.size()) |
| ariaElementsFromAttribute(ariaLabelledBy, aria_labeledbyAttr); |
| } |
| |
| void AccessibilityObject::ariaLabelledByReferencingElements(AccessibilityChildrenVector& labels) const |
| { |
| ariaElementsReferencedByAttribute(labels, aria_labelledbyAttr); |
| if (!labels.size()) |
| ariaElementsReferencedByAttribute(labels, aria_labeledbyAttr); |
| } |
| |
| void AccessibilityObject::ariaOwnsElements(AccessibilityChildrenVector& axObjects) const |
| { |
| ariaElementsFromAttribute(axObjects, aria_ownsAttr); |
| } |
| |
| void AccessibilityObject::ariaOwnsReferencingElements(AccessibilityChildrenVector& owners) const |
| { |
| ariaElementsReferencedByAttribute(owners, aria_ownsAttr); |
| } |
| |
| void AccessibilityObject::setIsIgnoredFromParentDataForChild(AccessibilityObject* child) |
| { |
| if (!child) |
| return; |
| |
| if (child->parentObject() != this) { |
| child->clearIsIgnoredFromParentData(); |
| return; |
| } |
| |
| AccessibilityIsIgnoredFromParentData result = AccessibilityIsIgnoredFromParentData(this); |
| if (!m_isIgnoredFromParentData.isNull()) { |
| result.isAXHidden = m_isIgnoredFromParentData.isAXHidden || equalLettersIgnoringASCIICase(child->getAttribute(aria_hiddenAttr), "true"); |
| result.isPresentationalChildOfAriaRole = m_isIgnoredFromParentData.isPresentationalChildOfAriaRole || ariaRoleHasPresentationalChildren(); |
| result.isDescendantOfBarrenParent = m_isIgnoredFromParentData.isDescendantOfBarrenParent || !canHaveChildren(); |
| } else { |
| result.isAXHidden = child->isAXHidden(); |
| result.isPresentationalChildOfAriaRole = child->isPresentationalChildOfAriaRole(); |
| result.isDescendantOfBarrenParent = child->isDescendantOfBarrenParent(); |
| } |
| |
| child->setIsIgnoredFromParentData(result); |
| } |
| |
| } // namespace WebCore |