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