ui::AXRange< AXPositionType > Class Template Reference

#include <ax_range.h>

Classes
class	Iterator

Public Types
using	AXPositionInstance = std::unique_ptr< AXPositionType >

Public Member Functions
	AXRange ()
	AXRange (AXPositionInstance anchor, AXPositionInstance focus)
	AXRange (const AXRange &other)=delete
	AXRange (AXRange &&other)
virtual	~AXRange ()=default
AXPositionType *	anchor () const
AXPositionType *	focus () const
AXRange &	operator= (const AXRange &other)=delete
AXRange &	operator= (AXRange &&other)
bool	operator== (const AXRange &other) const
bool	operator!= (const AXRange &other) const
AXRange	AsForwardRange () const
AXRange	AsBackwardRange () const
bool	IsCollapsed () const
bool	IsLeafTextRange () const
bool	IsNull () const
std::string	ToString () const
Iterator	begin () const
Iterator	end () const
std::u16string	GetText (AXTextConcatenationBehavior concatenation_behavior=AXTextConcatenationBehavior::kAsTextContent, int max_count=-1, bool include_ignored=false, size_t *appended_newlines_count=nullptr) const
std::vector< gfx::Rect >	GetRects (AXRangeRectDelegate *delegate) const

Static Public Member Functions
static std::optional< int >	CompareEndpoints (const AXPositionType *first, const AXPositionType *second)

Detailed Description

template<class AXPositionType>
class ui::AXRange< AXPositionType >

Definition at line 51 of file ax_range.h.

Member Typedef Documentation

AXPositionInstance

template<class AXPositionType >

using ui::AXRange< AXPositionType >::AXPositionInstance = std::unique_ptr<AXPositionType>

Definition at line 53 of file ax_range.h.

Constructor & Destructor Documentation

AXRange() [1/4]

template<class AXPositionType >

ui::AXRange< AXPositionType >::AXRange ( )

inline

Definition at line 55 of file ax_range.h.

      : anchor_(AXPositionType::CreateNullPosition()),
        focus_(AXPositionType::CreateNullPosition()) {}

AXRange() [2/4]

template<class AXPositionType >

ui::AXRange< AXPositionType >::AXRange ( AXPositionInstance  anchor, AXPositionInstance  focus  )

inline

Definition at line 59 of file ax_range.h.

                                                               {
    anchor_ = anchor ? std::move(anchor) : AXPositionType::CreateNullPosition();
    focus_ = focus ? std::move(focus) : AXPositionType::CreateNullPosition();
  }

AXRange() [3/4]

template<class AXPositionType >

ui::AXRange< AXPositionType >::AXRange ( const AXRange< AXPositionType > &  other )

delete

AXRange() [4/4]

template<class AXPositionType >

ui::AXRange< AXPositionType >::AXRange ( AXRange< AXPositionType > &&  other )

inline

Definition at line 66 of file ax_range.h.

                           : AXRange() {
    anchor_.swap(other.anchor_);
    focus_.swap(other.focus_);
  }

~AXRange()

template<class AXPositionType >

virtual ui::AXRange< AXPositionType >::~AXRange ( )

virtualdefault

Member Function Documentation

anchor()

template<class AXPositionType >

AXPositionType * ui::AXRange< AXPositionType >::anchor ( ) const

inline

Definition at line 73 of file ax_range.h.

                                 {
    BASE_DCHECK(anchor_);
    return anchor_.get();
  }

AsBackwardRange()

template<class AXPositionType >

AXRange ui::AXRange< AXPositionType >::AsBackwardRange ( ) const

inline

Definition at line 135 of file ax_range.h.

                                  {
    return (CompareEndpoints(anchor(), focus()).value_or(0) < 0)
               ? AXRange(focus_->Clone(), anchor_->Clone())
               : AXRange(anchor_->Clone(), focus_->Clone());
  }

AsForwardRange()

template<class AXPositionType >

AXRange ui::AXRange< AXPositionType >::AsForwardRange ( ) const

inline

Definition at line 129 of file ax_range.h.

                                 {
    return (CompareEndpoints(anchor(), focus()).value_or(0) > 0)
               ? AXRange(focus_->Clone(), anchor_->Clone())
               : AXRange(anchor_->Clone(), focus_->Clone());
  }

begin()

template<class AXPositionType >

Iterator ui::AXRange< AXPositionType >::begin ( ) const

inline

Definition at line 258 of file ax_range.h.

                         {
    if (IsNull())
      return Iterator(nullptr, nullptr);
    AXRange forward_range = AsForwardRange();
    return Iterator(std::move(forward_range.anchor_),
                    std::move(forward_range.focus_));
  }

CompareEndpoints()

template<class AXPositionType >

static std::optional< int > ui::AXRange< AXPositionType >::CompareEndpoints ( const AXPositionType *  first, const AXPositionType *  second  )

inlinestatic

Definition at line 117 of file ax_range.h.

                                                                           {
    std::optional<int> tree_position_comparison =
        first->AsTreePosition()->CompareTo(*second->AsTreePosition());
 
    // When the tree comparison is nullopt, using value_or(1) forces a default
    // value of 1, making the following statement return nullopt as well.
    return (tree_position_comparison.value_or(1) != 0)
               ? tree_position_comparison
               : first->CompareTo(*second);
  }

end()

template<class AXPositionType >

Iterator ui::AXRange< AXPositionType >::end ( ) const

inline

Definition at line 266 of file ax_range.h.

                       {
    if (IsNull())
      return Iterator(nullptr, nullptr);
    AXRange forward_range = AsForwardRange();
    return Iterator(nullptr, std::move(forward_range.focus_));
  }

focus()

template<class AXPositionType >

AXPositionType * ui::AXRange< AXPositionType >::focus ( ) const

inline

Definition at line 78 of file ax_range.h.

                                {
    BASE_DCHECK(focus_);
    return focus_.get();
  }

GetRects()

template<class AXPositionType >

std::vector< gfx::Rect > ui::AXRange< AXPositionType >::GetRects ( AXRangeRectDelegate *  delegate ) const

inline

Definition at line 378 of file ax_range.h.

                                                                   {
    std::vector<gfx::Rect> rects;
 
    for (const AXRange& leaf_text_range : *this) {
      BASE_DCHECK(leaf_text_range.IsLeafTextRange());
      AXPositionType* current_line_start = leaf_text_range.anchor();
      AXPositionType* current_line_end = leaf_text_range.focus();
 
      // For text anchors, we retrieve the bounding rectangles of its text
      // content. For non-text anchors (such as checkboxes, images, etc.), we
      // want to directly retrieve their bounding rectangles.
      AXOffscreenResult offscreen_result;
      gfx::Rect current_rect =
          (current_line_start->IsInLineBreak() ||
           current_line_start->IsInTextObject())
              ? delegate->GetInnerTextRangeBoundsRect(
                    current_line_start->tree_id(),
                    current_line_start->anchor_id(),
                    current_line_start->text_offset(),
                    current_line_end->text_offset(),
                    ui::AXClippingBehavior::kUnclipped, &offscreen_result)
              : delegate->GetBoundsRect(current_line_start->tree_id(),
                                        current_line_start->anchor_id(),
                                        &offscreen_result);
 
      // If the bounding box of the current range is clipped because it lies
      // outside an ancestor’s bounds, then the bounding box is pushed to the
      // nearest edge of such ancestor's bounds, with its width and height
      // forced to be 1, and the node will be marked as "offscreen".
      //
      // Only add rectangles that are not empty and not marked as "offscreen".
      //
      // See the documentation for how bounding boxes are calculated in AXTree:
      // https://chromium.googlesource.com/chromium/src/+/HEAD/docs/accessibility/offscreen.md
      if (!current_rect.IsEmpty() &&
          offscreen_result == AXOffscreenResult::kOnscreen)
        rects.push_back(current_rect);
    }
    return rects;
  }

GetText()

template<class AXPositionType >

std::u16string ui::AXRange< AXPositionType >::GetText ( AXTextConcatenationBehavior  concatenation_behavior = AXTextConcatenationBehavior::kAsTextContent, int  max_count = -1, bool  include_ignored = false, size_t *  appended_newlines_count = nullptr  ) const

inline

Definition at line 278 of file ax_range.h.

                                                                          {
    if (max_count == 0 || IsNull())
      return std::u16string();
 
    std::optional<int> endpoint_comparison =
        CompareEndpoints(anchor(), focus());
    if (!endpoint_comparison)
      return std::u16string();
 
    AXPositionInstance start = (endpoint_comparison.value() < 0)
                                   ? anchor_->AsLeafTextPosition()
                                   : focus_->AsLeafTextPosition();
    AXPositionInstance end = (endpoint_comparison.value() < 0)
                                 ? focus_->AsLeafTextPosition()
                                 : anchor_->AsLeafTextPosition();
 
    std::u16string range_text;
    size_t computed_newlines_count = 0;
    bool is_first_non_whitespace_leaf = true;
    bool crossed_paragraph_boundary = false;
    bool is_first_unignored_leaf = true;
    bool found_trailing_newline = false;
 
    while (!start->IsNullPosition()) {
      BASE_DCHECK(start->IsLeafTextPosition());
      BASE_DCHECK(start->text_offset() >= 0);
 
      if (include_ignored || !start->IsIgnored()) {
        if (concatenation_behavior ==
                AXTextConcatenationBehavior::kAsInnerText &&
            !start->IsInWhiteSpace()) {
          if (is_first_non_whitespace_leaf) {
            // The first non-whitespace leaf in the range could be preceded by
            // whitespace spanning even before the start of this range, we need
            // to check such positions in order to correctly determine if this
            // is a paragraph's start (see |AXPosition::AtStartOfParagraph|).
            crossed_paragraph_boundary =
                !is_first_unignored_leaf && start->AtStartOfParagraph();
          }
 
          // When preserving layout line breaks, don't append `\n` next if the
          // previous leaf position was a <br> (already ending with a newline).
          if (crossed_paragraph_boundary && !found_trailing_newline) {
            range_text += base::ASCIIToUTF16("\n");
            computed_newlines_count++;
          }
 
          is_first_non_whitespace_leaf = false;
          crossed_paragraph_boundary = false;
        }
 
        int current_end_offset = (start->GetAnchor() != end->GetAnchor())
                                     ? start->MaxTextOffset()
                                     : end->text_offset();
 
        if (current_end_offset > start->text_offset()) {
          int characters_to_append =
              (max_count > 0)
                  ? std::min(max_count - static_cast<int>(range_text.length()),
                             current_end_offset - start->text_offset())
                  : current_end_offset - start->text_offset();
 
          range_text += start->GetText().substr(start->text_offset(),
                                                characters_to_append);
 
          // Collapse all whitespace following any line break.
          found_trailing_newline =
              start->IsInLineBreak() ||
              (found_trailing_newline && start->IsInWhiteSpace());
        }
 
        BASE_DCHECK(max_count < 0 ||
                    static_cast<int>(range_text.length()) <= max_count);
        is_first_unignored_leaf = false;
      }
 
      if (start->GetAnchor() == end->GetAnchor() ||
          static_cast<int>(range_text.length()) == max_count) {
        break;
      } else if (concatenation_behavior ==
                     AXTextConcatenationBehavior::kAsInnerText &&
                 !crossed_paragraph_boundary && !is_first_non_whitespace_leaf) {
        start = start->CreateNextLeafTextPosition(&crossed_paragraph_boundary);
      } else {
        start = start->CreateNextLeafTextPosition();
      }
    }
 
    if (appended_newlines_count)
      *appended_newlines_count = computed_newlines_count;
    return range_text;
  }

IsCollapsed()

template<class AXPositionType >

bool ui::AXRange< AXPositionType >::IsCollapsed ( ) const

inline

Definition at line 141 of file ax_range.h.

{ return !IsNull() && *anchor_ == *focus_; }

IsLeafTextRange()

template<class AXPositionType >

bool ui::AXRange< AXPositionType >::IsLeafTextRange ( ) const

inline

Definition at line 145 of file ax_range.h.

                               {
    return !IsNull() && anchor_->GetAnchor() == focus_->GetAnchor() &&
           anchor_->IsLeafTextPosition() && focus_->IsLeafTextPosition();
  }

IsNull()

template<class AXPositionType >

bool ui::AXRange< AXPositionType >::IsNull ( ) const

inline

Definition at line 150 of file ax_range.h.

                      {
    BASE_DCHECK(anchor_ && focus_);
    return anchor_->IsNullPosition() || focus_->IsNullPosition();
  }

operator!=()

template<class AXPositionType >

bool ui::AXRange< AXPositionType >::operator!= ( const AXRange< AXPositionType > &  other ) const

inline

Definition at line 102 of file ax_range.h.

{ return !(*this == other); }

operator=() [1/2]

template<class AXPositionType >

AXRange & ui::AXRange< AXPositionType >::operator= ( AXRange< AXPositionType > &&  other )

inline

Definition at line 85 of file ax_range.h.

                                      {
    if (this != &other) {
      anchor_ = AXPositionType::CreateNullPosition();
      focus_ = AXPositionType::CreateNullPosition();
      anchor_.swap(other.anchor_);
      focus_.swap(other.focus_);
    }
    return *this;
  }

operator=() [2/2]

template<class AXPositionType >

AXRange & ui::AXRange< AXPositionType >::operator= ( const AXRange< AXPositionType > &  other )

delete

operator==()

template<class AXPositionType >

bool ui::AXRange< AXPositionType >::operator== ( const AXRange< AXPositionType > &  other ) const

inline

Definition at line 95 of file ax_range.h.

                                              {
    if (IsNull())
      return other.IsNull();
    return !other.IsNull() && *anchor_ == *other.anchor() &&
           *focus_ == *other.focus();
  }

ToString()

template<class AXPositionType >

std::string ui::AXRange< AXPositionType >::ToString ( ) const

inline

Definition at line 155 of file ax_range.h.

                             {
    return "Range\nAnchor:" + anchor_->ToString() +
           "\nFocus:" + focus_->ToString();
  }

---

The documentation for this class was generated from the following files:

• third_party/accessibility/ax/ax_position.h
• third_party/accessibility/ax/ax_range.h