tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

AccIterator.h (9572B)

      1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
      2 /* vim: set ts=2 et sw=2 tw=80: */
      3 /* This Source Code Form is subject to the terms of the Mozilla Public
      4 * License, v. 2.0. If a copy of the MPL was not distributed with this
      5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      6 
      7 #ifndef mozilla_a11y_AccIterator_h__
      8 #define mozilla_a11y_AccIterator_h__
      9 
     10 #include "Filters.h"
     11 #include "mozilla/a11y/DocAccessible.h"
     12 #include "nsTArray.h"
     13 
     14 #include <memory>
     15 
     16 class nsITreeView;
     17 
     18 namespace mozilla {
     19 namespace dom {
     20 class Element;
     21 }
     22 
     23 namespace a11y {
     24 class DocAccessibleParent;
     25 
     26 /**
     27 * AccIterable is a basic interface for iterators over accessibles.
     28 */
     29 class AccIterable {
     30 public:
     31  virtual ~AccIterable() {}
     32  virtual Accessible* Next() = 0;
     33 
     34 private:
     35  friend class Relation;
     36  std::unique_ptr<AccIterable> mNextIter;
     37 };
     38 
     39 /**
     40 * Allows to iterate through accessible children or subtree complying with
     41 * filter function.
     42 */
     43 class AccIterator : public AccIterable {
     44 public:
     45  AccIterator(const LocalAccessible* aRoot, filters::FilterFuncPtr aFilterFunc);
     46  virtual ~AccIterator();
     47 
     48  /**
     49   * Return next accessible complying with filter function. Return the first
     50   * accessible for the first time.
     51   */
     52  virtual LocalAccessible* Next() override;
     53 
     54 private:
     55  AccIterator();
     56  AccIterator(const AccIterator&);
     57  AccIterator& operator=(const AccIterator&);
     58 
     59  struct IteratorState {
     60    explicit IteratorState(const LocalAccessible* aParent,
     61                           IteratorState* mParentState = nullptr);
     62 
     63    const LocalAccessible* mParent;
     64    int32_t mIndex;
     65    IteratorState* mParentState;
     66  };
     67 
     68  filters::FilterFuncPtr mFilterFunc;
     69  IteratorState* mState;
     70 };
     71 
     72 /**
     73 * Allows to traverse through related accessibles that are pointing to the given
     74 * dependent accessible by relation attribute. This is typically used to query
     75 * implicit reverse relations; e.g. calculating the LABEL_FOR relation for a
     76 * label where that label was referenced using aria-labelledby.
     77 */
     78 class RelatedAccIterator : public AccIterable {
     79 public:
     80  /**
     81   * Constructor.
     82   *
     83   * @param aDocument         [in] the document accessible the related
     84   * &                         accessibles belong to.
     85   * @param aDependentContent [in] the content of dependent accessible that
     86   *                           relations were requested for
     87   * @param aRelAttr          [in] relation attribute that relations are
     88   *                           pointed by, null for all relations
     89   */
     90  RelatedAccIterator(DocAccessible* aDocument, nsIContent* aDependentContent,
     91                     nsAtom* aRelAttr);
     92 
     93  virtual ~RelatedAccIterator() {}
     94 
     95  /**
     96   * Return next related accessible for the given dependent accessible.
     97   */
     98  virtual LocalAccessible* Next() override;
     99 
    100 private:
    101  RelatedAccIterator();
    102  RelatedAccIterator(const RelatedAccIterator&);
    103  RelatedAccIterator& operator=(const RelatedAccIterator&);
    104 
    105  DocAccessible* mDocument;
    106  nsIContent* mDependentContent;
    107  nsAtom* mRelAttr;
    108  DocAccessible::AttrRelProviders* mProviders;
    109  uint32_t mIndex;
    110  bool mIsWalkingDependentElements;
    111 };
    112 
    113 /**
    114 * Used to iterate through HTML labels associated with the given accessible.
    115 */
    116 class HTMLLabelIterator : public AccIterable {
    117 public:
    118  enum LabelFilter { eAllLabels, eSkipAncestorLabel };
    119 
    120  HTMLLabelIterator(DocAccessible* aDocument,
    121                    const LocalAccessible* aAccessible,
    122                    LabelFilter aFilter = eAllLabels);
    123 
    124  virtual ~HTMLLabelIterator() {}
    125 
    126  /**
    127   * Return next label accessible associated with the given element.
    128   */
    129  virtual LocalAccessible* Next() override;
    130 
    131 private:
    132  HTMLLabelIterator();
    133  HTMLLabelIterator(const HTMLLabelIterator&);
    134  HTMLLabelIterator& operator=(const HTMLLabelIterator&);
    135 
    136  bool IsLabel(LocalAccessible* aLabel);
    137 
    138  RelatedAccIterator mRelIter;
    139  // XXX: replace it on weak reference (bug 678429), it's safe to use raw
    140  // pointer now because iterators life cycle is short.
    141  const LocalAccessible* mAcc;
    142  LabelFilter mLabelFilter;
    143 };
    144 
    145 /**
    146 * Used to iterate through HTML outputs associated with the given element.
    147 */
    148 class HTMLOutputIterator : public AccIterable {
    149 public:
    150  HTMLOutputIterator(DocAccessible* aDocument, nsIContent* aElement);
    151  virtual ~HTMLOutputIterator() {}
    152 
    153  /**
    154   * Return next output accessible associated with the given element.
    155   */
    156  virtual LocalAccessible* Next() override;
    157 
    158 private:
    159  HTMLOutputIterator();
    160  HTMLOutputIterator(const HTMLOutputIterator&);
    161  HTMLOutputIterator& operator=(const HTMLOutputIterator&);
    162 
    163  RelatedAccIterator mRelIter;
    164 };
    165 
    166 /**
    167 * Used to iterate through XUL labels associated with the given element.
    168 */
    169 class XULLabelIterator : public AccIterable {
    170 public:
    171  XULLabelIterator(DocAccessible* aDocument, nsIContent* aElement);
    172  virtual ~XULLabelIterator() {}
    173 
    174  /**
    175   * Return next label accessible associated with the given element.
    176   */
    177  virtual LocalAccessible* Next() override;
    178 
    179 private:
    180  XULLabelIterator();
    181  XULLabelIterator(const XULLabelIterator&);
    182  XULLabelIterator& operator=(const XULLabelIterator&);
    183 
    184  RelatedAccIterator mRelIter;
    185 };
    186 
    187 /**
    188 * Used to iterate through XUL descriptions associated with the given element.
    189 */
    190 class XULDescriptionIterator : public AccIterable {
    191 public:
    192  XULDescriptionIterator(DocAccessible* aDocument, nsIContent* aElement);
    193  virtual ~XULDescriptionIterator() {}
    194 
    195  /**
    196   * Return next description accessible associated with the given element.
    197   */
    198  virtual LocalAccessible* Next() override;
    199 
    200 private:
    201  XULDescriptionIterator();
    202  XULDescriptionIterator(const XULDescriptionIterator&);
    203  XULDescriptionIterator& operator=(const XULDescriptionIterator&);
    204 
    205  RelatedAccIterator mRelIter;
    206 };
    207 
    208 /**
    209 * Used to iterate through elements referenced through explicitly set
    210 * attr-elements or IDs listed in a content attribute. Note, any method used to
    211 * iterate through IDs, elements, or accessibles moves iterator to next
    212 * position.
    213 */
    214 class AssociatedElementsIterator : public AccIterable {
    215 public:
    216  AssociatedElementsIterator(DocAccessible* aDoc, nsIContent* aContent,
    217                             nsAtom* aIDRefsAttr);
    218  virtual ~AssociatedElementsIterator() {}
    219 
    220  /**
    221   * Return next ID.
    222   */
    223  const nsDependentSubstring NextID();
    224 
    225  /**
    226   * Return next element.
    227   */
    228  dom::Element* NextElem();
    229 
    230  /**
    231   * Return the element with the given ID.
    232   */
    233  static dom::Element* GetElem(nsIContent* aContent, const nsAString& aID);
    234  dom::Element* GetElem(const nsDependentSubstring& aID);
    235 
    236  // AccIterable
    237  virtual LocalAccessible* Next() override;
    238 
    239 private:
    240  AssociatedElementsIterator();
    241  AssociatedElementsIterator(const AssociatedElementsIterator&);
    242  AssociatedElementsIterator operator=(const AssociatedElementsIterator&);
    243 
    244  nsString mIDs;
    245  nsIContent* mContent;
    246  DocAccessible* mDoc;
    247  nsAString::index_type mCurrIdx;
    248  nsTArray<dom::Element*> mElements;
    249  uint32_t mElemIdx;
    250 };
    251 
    252 /**
    253 * Iterator that points to a single accessible returning it on the first call
    254 * to Next().
    255 */
    256 class SingleAccIterator : public AccIterable {
    257 public:
    258  explicit SingleAccIterator(Accessible* aTarget) : mAcc(aTarget) {}
    259  virtual ~SingleAccIterator() {}
    260 
    261  virtual Accessible* Next() override;
    262 
    263 private:
    264  SingleAccIterator();
    265  SingleAccIterator(const SingleAccIterator&);
    266  SingleAccIterator& operator=(const SingleAccIterator&);
    267 
    268  Accessible* mAcc;
    269 };
    270 
    271 /**
    272 * Used to iterate items of the given item container.
    273 */
    274 class ItemIterator : public AccIterable {
    275 public:
    276  explicit ItemIterator(const Accessible* aItemContainer)
    277      : mContainer(aItemContainer), mAnchor(nullptr) {}
    278 
    279  virtual Accessible* Next() override;
    280 
    281 private:
    282  ItemIterator() = delete;
    283  ItemIterator(const ItemIterator&) = delete;
    284  ItemIterator& operator=(const ItemIterator&) = delete;
    285 
    286  const Accessible* mContainer;
    287  Accessible* mAnchor;
    288 };
    289 
    290 /**
    291 * Used to iterate through XUL tree items of the same level.
    292 */
    293 class XULTreeItemIterator : public AccIterable {
    294 public:
    295  XULTreeItemIterator(const XULTreeAccessible* aXULTree, nsITreeView* aTreeView,
    296                      int32_t aRowIdx);
    297  virtual ~XULTreeItemIterator() {}
    298 
    299  virtual LocalAccessible* Next() override;
    300 
    301 private:
    302  XULTreeItemIterator() = delete;
    303  XULTreeItemIterator(const XULTreeItemIterator&) = delete;
    304  XULTreeItemIterator& operator=(const XULTreeItemIterator&) = delete;
    305 
    306  const XULTreeAccessible* mXULTree;
    307  nsITreeView* mTreeView;
    308  int32_t mRowCount;
    309  int32_t mContainerLevel;
    310  int32_t mCurrRowIdx;
    311 };
    312 
    313 /**
    314 * Used to iterate through a sequence of RemoteAccessibles supplied as an array
    315 * of ids. Such id arrays are included in the RemoteAccessible cache.
    316 */
    317 class RemoteAccIterator : public AccIterable {
    318 public:
    319  /**
    320   * Construct with a reference to an array owned somewhere else; e.g. a
    321   * RemoteAccessible cache.
    322   */
    323  RemoteAccIterator(const nsTArray<uint64_t>& aIds, DocAccessibleParent* aDoc)
    324      : mIds(aIds), mDoc(aDoc), mIndex(0) {}
    325 
    326  virtual ~RemoteAccIterator() = default;
    327 
    328  virtual Accessible* Next() override;
    329 
    330 private:
    331  const nsTArray<uint64_t>& mIds;
    332  DocAccessibleParent* mDoc;
    333  uint32_t mIndex;
    334 };
    335 
    336 /**
    337 * Used to iterate through an array of accessibles
    338 */
    339 class ArrayAccIterator : public AccIterable {
    340 public:
    341  explicit ArrayAccIterator(nsTArray<Accessible*>&& aAccs)
    342      : mAccs(std::move(aAccs)), mIndex(0) {}
    343 
    344  virtual ~ArrayAccIterator() = default;
    345 
    346  virtual Accessible* Next() override;
    347 
    348 private:
    349  nsTArray<Accessible*> mAccs;
    350  uint32_t mIndex;
    351 };
    352 
    353 }  // namespace a11y
    354 }  // namespace mozilla
    355 
    356 #endif