accessible/base/AccIterator.h

   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 "DocAccessible.h"
  11 #include "Filters.h"
  12
  13 #include <memory>
  14
  15 class nsITreeView;
  16
  17 namespace mozilla {
  18 namespace a11y {
  19
  20 /**
  21  * AccIterable is a basic interface for iterators over accessibles.
  22  */
  23 class AccIterable {
  24  public:
  25   virtual ~AccIterable() {}
  26   virtual Accessible* Next() = 0;
  27
  28  private:
  29   friend class Relation;
  30   std::unique_ptr<AccIterable> mNextIter;
  31 };
  32
  33 /**
  34  * Allows to iterate through accessible children or subtree complying with
  35  * filter function.
  36  */
  37 class AccIterator : public AccIterable {
  38  public:
  39   AccIterator(const Accessible* aRoot, filters::FilterFuncPtr aFilterFunc);
  40   virtual ~AccIterator();
  41
  42   /**
  43    * Return next accessible complying with filter function. Return the first
  44    * accessible for the first time.
  45    */
  46   virtual Accessible* Next() override;
  47
  48  private:
  49   AccIterator();
  50   AccIterator(const AccIterator&);
  51   AccIterator& operator=(const AccIterator&);
  52
  53   struct IteratorState {
  54     explicit IteratorState(const Accessible* aParent,
  55                            IteratorState* mParentState = nullptr);
  56
  57     const Accessible* mParent;
  58     int32_t mIndex;
  59     IteratorState* mParentState;
  60   };
  61
  62   filters::FilterFuncPtr mFilterFunc;
  63   IteratorState* mState;
  64 };
  65
  66 /**
  67  * Allows to traverse through related accessibles that are pointing to the given
  68  * dependent accessible by relation attribute.
  69  */
  70 class RelatedAccIterator : public AccIterable {
  71  public:
  72   /**
  73    * Constructor.
  74    *
  75    * @param aDocument         [in] the document accessible the related
  76    * &                         accessibles belong to.
  77    * @param aDependentContent [in] the content of dependent accessible that
  78    *                           relations were requested for
  79    * @param aRelAttr          [in] relation attribute that relations are
  80    *                           pointed by
  81    */
  82   RelatedAccIterator(DocAccessible* aDocument, nsIContent* aDependentContent,
  83                      nsAtom* aRelAttr);
  84
  85   virtual ~RelatedAccIterator() {}
  86
  87   /**
  88    * Return next related accessible for the given dependent accessible.
  89    */
  90   virtual Accessible* Next() override;
  91
  92  private:
  93   RelatedAccIterator();
  94   RelatedAccIterator(const RelatedAccIterator&);
  95   RelatedAccIterator& operator=(const RelatedAccIterator&);
  96
  97   DocAccessible* mDocument;
  98   nsAtom* mRelAttr;
  99   DocAccessible::AttrRelProviders* mProviders;
 100   nsIContent* mBindingParent;
 101   uint32_t mIndex;
 102 };
 103
 104 /**
 105  * Used to iterate through HTML labels associated with the given accessible.
 106  */
 107 class HTMLLabelIterator : public AccIterable {
 108  public:
 109   enum LabelFilter { eAllLabels, eSkipAncestorLabel };
 110
 111   HTMLLabelIterator(DocAccessible* aDocument, const Accessible* aAccessible,
 112                     LabelFilter aFilter = eAllLabels);
 113
 114   virtual ~HTMLLabelIterator() {}
 115
 116   /**
 117    * Return next label accessible associated with the given element.
 118    */
 119   virtual Accessible* Next() override;
 120
 121  private:
 122   HTMLLabelIterator();
 123   HTMLLabelIterator(const HTMLLabelIterator&);
 124   HTMLLabelIterator& operator=(const HTMLLabelIterator&);
 125
 126   bool IsLabel(Accessible* aLabel);
 127
 128   RelatedAccIterator mRelIter;
 129   // XXX: replace it on weak reference (bug 678429), it's safe to use raw
 130   // pointer now because iterators life cycle is short.
 131   const Accessible* mAcc;
 132   LabelFilter mLabelFilter;
 133 };
 134
 135 /**
 136  * Used to iterate through HTML outputs associated with the given element.
 137  */
 138 class HTMLOutputIterator : public AccIterable {
 139  public:
 140   HTMLOutputIterator(DocAccessible* aDocument, nsIContent* aElement);
 141   virtual ~HTMLOutputIterator() {}
 142
 143   /**
 144    * Return next output accessible associated with the given element.
 145    */
 146   virtual Accessible* Next() override;
 147
 148  private:
 149   HTMLOutputIterator();
 150   HTMLOutputIterator(const HTMLOutputIterator&);
 151   HTMLOutputIterator& operator=(const HTMLOutputIterator&);
 152
 153   RelatedAccIterator mRelIter;
 154 };
 155
 156 /**
 157  * Used to iterate through XUL labels associated with the given element.
 158  */
 159 class XULLabelIterator : public AccIterable {
 160  public:
 161   XULLabelIterator(DocAccessible* aDocument, nsIContent* aElement);
 162   virtual ~XULLabelIterator() {}
 163
 164   /**
 165    * Return next label accessible associated with the given element.
 166    */
 167   virtual Accessible* Next() override;
 168
 169  private:
 170   XULLabelIterator();
 171   XULLabelIterator(const XULLabelIterator&);
 172   XULLabelIterator& operator=(const XULLabelIterator&);
 173
 174   RelatedAccIterator mRelIter;
 175 };
 176
 177 /**
 178  * Used to iterate through XUL descriptions associated with the given element.
 179  */
 180 class XULDescriptionIterator : public AccIterable {
 181  public:
 182   XULDescriptionIterator(DocAccessible* aDocument, nsIContent* aElement);
 183   virtual ~XULDescriptionIterator() {}
 184
 185   /**
 186    * Return next description accessible associated with the given element.
 187    */
 188   virtual Accessible* Next() override;
 189
 190  private:
 191   XULDescriptionIterator();
 192   XULDescriptionIterator(const XULDescriptionIterator&);
 193   XULDescriptionIterator& operator=(const XULDescriptionIterator&);
 194
 195   RelatedAccIterator mRelIter;
 196 };
 197
 198 /**
 199  * Used to iterate through IDs, elements or accessibles pointed by IDRefs
 200  * attribute. Note, any method used to iterate through IDs, elements, or
 201  * accessibles moves iterator to next position.
 202  */
 203 class IDRefsIterator : public AccIterable {
 204  public:
 205   IDRefsIterator(DocAccessible* aDoc, nsIContent* aContent,
 206                  nsAtom* aIDRefsAttr);
 207   virtual ~IDRefsIterator() {}
 208
 209   /**
 210    * Return next ID.
 211    */
 212   const nsDependentSubstring NextID();
 213
 214   /**
 215    * Return next element.
 216    */
 217   nsIContent* NextElem();
 218
 219   /**
 220    * Return the element with the given ID.
 221    */
 222   static dom::Element* GetElem(nsIContent* aContent, const nsAString& aID);
 223   dom::Element* GetElem(const nsDependentSubstring& aID);
 224
 225   // AccIterable
 226   virtual Accessible* Next() override;
 227
 228  private:
 229   IDRefsIterator();
 230   IDRefsIterator(const IDRefsIterator&);
 231   IDRefsIterator operator=(const IDRefsIterator&);
 232
 233   nsString mIDs;
 234   nsIContent* mContent;
 235   DocAccessible* mDoc;
 236   nsAString::index_type mCurrIdx;
 237 };
 238
 239 /**
 240  * Iterator that points to a single accessible returning it on the first call
 241  * to Next().
 242  */
 243 class SingleAccIterator : public AccIterable {
 244  public:
 245   explicit SingleAccIterator(Accessible* aTarget) : mAcc(aTarget) {}
 246   virtual ~SingleAccIterator() {}
 247
 248   virtual Accessible* Next() override;
 249
 250  private:
 251   SingleAccIterator();
 252   SingleAccIterator(const SingleAccIterator&);
 253   SingleAccIterator& operator=(const SingleAccIterator&);
 254
 255   RefPtr<Accessible> mAcc;
 256 };
 257
 258 /**
 259  * Used to iterate items of the given item container.
 260  */
 261 class ItemIterator : public AccIterable {
 262  public:
 263   explicit ItemIterator(const Accessible* aItemContainer)
 264       : mContainer(aItemContainer), mAnchor(nullptr) {}
 265   virtual ~ItemIterator() {}
 266
 267   virtual Accessible* Next() override;
 268
 269  private:
 270   ItemIterator() = delete;
 271   ItemIterator(const ItemIterator&) = delete;
 272   ItemIterator& operator=(const ItemIterator&) = delete;
 273
 274   const Accessible* mContainer;
 275   Accessible* mAnchor;
 276 };
 277
 278 /**
 279  * Used to iterate through XUL tree items of the same level.
 280  */
 281 class XULTreeItemIterator : public AccIterable {
 282  public:
 283   XULTreeItemIterator(const XULTreeAccessible* aXULTree, nsITreeView* aTreeView,
 284                       int32_t aRowIdx);
 285   virtual ~XULTreeItemIterator() {}
 286
 287   virtual Accessible* Next() override;
 288
 289  private:
 290   XULTreeItemIterator() = delete;
 291   XULTreeItemIterator(const XULTreeItemIterator&) = delete;
 292   XULTreeItemIterator& operator=(const XULTreeItemIterator&) = delete;
 293
 294   const XULTreeAccessible* mXULTree;
 295   nsITreeView* mTreeView;
 296   int32_t mRowCount;
 297   int32_t mContainerLevel;
 298   int32_t mCurrRowIdx;
 299 };
 300
 301 }  // namespace a11y
 302 }  // namespace mozilla
 303
 304 #endif