accessible/mac/RotorRules.h

   1 /* clang-format off */
   2 /* -*- Mode: Objective-C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   3 /* clang-format on */
   4 /* This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   7
   8 #import "mozAccessible.h"
   9 #include "Pivot.h"
  10
  11 using namespace mozilla::a11y;
  12
  13 /**
  14  * This rule matches all accessibles that satisfy the "boilerplate"
  15  * pivot conditions and have a corresponding native accessible.
  16  */
  17 class RotorRule : public PivotRule {
  18  public:
  19   explicit RotorRule(Accessible* aDirectDescendantsFrom,
  20                      const nsString& aSearchText);
  21   explicit RotorRule(const nsString& aSearchText);
  22   uint16_t Match(Accessible* aAcc) override;
  23
  24  private:
  25   Accessible* mDirectDescendantsFrom;
  26   const nsString& mSearchText;
  27 };
  28
  29 /**
  30  * This rule matches all accessibles of a given role.
  31  */
  32 class RotorRoleRule : public RotorRule {
  33  public:
  34   explicit RotorRoleRule(role aRole, Accessible* aDirectDescendantsFrom,
  35                          const nsString& aSearchText);
  36   explicit RotorRoleRule(role aRole, const nsString& aSearchText);
  37   uint16_t Match(Accessible* aAcc) override;
  38
  39  private:
  40   role mRole;
  41 };
  42
  43 class RotorMacRoleRule : public RotorRule {
  44  public:
  45   explicit RotorMacRoleRule(NSString* aRole, const nsString& aSearchText);
  46   explicit RotorMacRoleRule(NSString* aRole, Accessible* aDirectDescendantsFrom,
  47                             const nsString& aSearchText);
  48   ~RotorMacRoleRule();
  49   virtual uint16_t Match(Accessible* aAcc) override;
  50
  51  protected:
  52   NSString* mMacRole;
  53 };
  54
  55 class RotorControlRule final : public RotorRule {
  56  public:
  57   explicit RotorControlRule(Accessible* aDirectDescendantsFrom,
  58                             const nsString& aSearchText);
  59   explicit RotorControlRule(const nsString& aSearchText);
  60
  61   virtual uint16_t Match(Accessible* aAcc) override;
  62 };
  63
  64 class RotorTextEntryRule final : public RotorRule {
  65  public:
  66   explicit RotorTextEntryRule(Accessible* aDirectDescendantsFrom,
  67                               const nsString& aSearchText);
  68   explicit RotorTextEntryRule(const nsString& aSearchText);
  69
  70   virtual uint16_t Match(Accessible* aAcc) override;
  71 };
  72
  73 class RotorLinkRule : public RotorRule {
  74  public:
  75   explicit RotorLinkRule(const nsString& aSearchText);
  76   explicit RotorLinkRule(Accessible* aDirectDescendantsFrom,
  77                          const nsString& aSearchText);
  78
  79   virtual uint16_t Match(Accessible* aAcc) override;
  80 };
  81
  82 class RotorVisitedLinkRule final : public RotorLinkRule {
  83  public:
  84   explicit RotorVisitedLinkRule(const nsString& aSearchText);
  85   explicit RotorVisitedLinkRule(Accessible* aDirectDescendantsFrom,
  86                                 const nsString& aSearchText);
  87
  88   virtual uint16_t Match(Accessible* aAcc) override;
  89 };
  90
  91 class RotorUnvisitedLinkRule final : public RotorLinkRule {
  92  public:
  93   explicit RotorUnvisitedLinkRule(const nsString& aSearchText);
  94   explicit RotorUnvisitedLinkRule(Accessible* aDirectDescendantsFrom,
  95                                   const nsString& aSearchText);
  96
  97   virtual uint16_t Match(Accessible* aAcc) override;
  98 };
  99
 100 /**
 101  * This rule matches all accessibles that satisfy the "boilerplate"
 102  * pivot conditions and have a corresponding native accessible.
 103  */
 104 class RotorNotMacRoleRule : public RotorMacRoleRule {
 105  public:
 106   explicit RotorNotMacRoleRule(NSString* aMacRole,
 107                                Accessible* aDirectDescendantsFrom,
 108                                const nsString& aSearchText);
 109   explicit RotorNotMacRoleRule(NSString* aMacRole, const nsString& aSearchText);
 110   uint16_t Match(Accessible* aAcc) override;
 111 };
 112
 113 class RotorStaticTextRule : public RotorRule {
 114  public:
 115   explicit RotorStaticTextRule(const nsString& aSearchText);
 116   explicit RotorStaticTextRule(Accessible* aDirectDescendantsFrom,
 117                                const nsString& aSearchText);
 118
 119   virtual uint16_t Match(Accessible* aAcc) override;
 120 };
 121
 122 class RotorHeadingLevelRule : public RotorRoleRule {
 123  public:
 124   explicit RotorHeadingLevelRule(int32_t aLevel, const nsString& aSearchText);
 125   explicit RotorHeadingLevelRule(int32_t aLevel,
 126                                  Accessible* aDirectDescendantsFrom,
 127                                  const nsString& aSearchText);
 128
 129   virtual uint16_t Match(Accessible* aAcc) override;
 130
 131  private:
 132   int32_t mLevel;
 133 };
 134
 135 class RotorLiveRegionRule : public RotorRule {
 136  public:
 137   explicit RotorLiveRegionRule(Accessible* aDirectDescendantsFrom,
 138                                const nsString& aSearchText)
 139       : RotorRule(aDirectDescendantsFrom, aSearchText) {}
 140   explicit RotorLiveRegionRule(const nsString& aSearchText)
 141       : RotorRule(aSearchText) {}
 142
 143   uint16_t Match(Accessible* aAcc) override;
 144 };