tor-browser

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

RotorRules.h (5086B)

      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 };
    145 
    146 class RotorFocusableRule : public RotorRule {
    147 public:
    148  explicit RotorFocusableRule(const nsString& aSearchText);
    149  explicit RotorFocusableRule(Accessible* aDirectDescendantsFrom,
    150                              const nsString& aSearchText);
    151 
    152  virtual uint16_t Match(Accessible* aAcc) override;
    153 };