Home | History | Annotate | Download | only in accessibility 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef CHROME_BROWSER_ACCESSIBILITY_ACCESSIBILITY_EVENTS_H_
      6 #define CHROME_BROWSER_ACCESSIBILITY_ACCESSIBILITY_EVENTS_H_
      7 
      8 #include <string>
      9 #include "base/compiler_specific.h"
     10 #include "ui/base/accessibility/accessibility_types.h"
     11 
     12 class AccessibilityControlInfo;
     13 class AccessibilityMenuInfo;
     14 class AccessibilityWindowInfo;
     15 class Profile;
     16 
     17 namespace base {
     18 class DictionaryValue;
     19 }
     20 
     21 // Notify the ExtensionAccessibilityEventRouter of the given accessibility
     22 // event and AccessibilityEventInfo details. Will not send if the profile's
     23 // pause level is nonzero (using profile->PauseAccessibilityEvents).
     24 void SendControlAccessibilityNotification(
     25     ui::AccessibilityTypes::Event event,
     26     AccessibilityControlInfo* info);
     27 
     28 void SendMenuAccessibilityNotification(
     29     ui::AccessibilityTypes::Event event,
     30     AccessibilityMenuInfo* info);
     31 
     32 void SendWindowAccessibilityNotification(
     33     ui::AccessibilityTypes::Event event,
     34     AccessibilityWindowInfo* info);
     35 
     36 // Abstract parent class for accessibility event information passed to event
     37 // listeners.
     38 class AccessibilityEventInfo {
     39  public:
     40   virtual ~AccessibilityEventInfo() {}
     41 
     42   // Serialize this class as a DictionaryValue that can be converted to
     43   // a JavaScript object.
     44   virtual void SerializeToDict(base::DictionaryValue* dict) const = 0;
     45 
     46   Profile* profile() const { return profile_; }
     47 
     48  protected:
     49   explicit AccessibilityEventInfo(Profile* profile) : profile_(profile) {}
     50 
     51   // The profile this control belongs to.
     52   Profile* profile_;
     53 };
     54 
     55 // Abstract parent class for accessibility information about a control
     56 // passed to event listeners.
     57 class AccessibilityControlInfo : public AccessibilityEventInfo {
     58  public:
     59   virtual ~AccessibilityControlInfo();
     60 
     61   // Serialize this class as a DictionaryValue that can be converted to
     62   // a JavaScript object.
     63   virtual void SerializeToDict(base::DictionaryValue* dict) const OVERRIDE;
     64 
     65   // Return the specific type of this control, which will be one of the
     66   // string constants defined in extension_accessibility_api_constants.h.
     67   virtual const char* type() const = 0;
     68 
     69   const std::string& name() const { return name_; }
     70 
     71   const std::string& context() const { return context_; }
     72 
     73  protected:
     74   AccessibilityControlInfo(Profile* profile,
     75                            const std::string& name);
     76 
     77   void set_context(const std::string& context) { context_ = context; }
     78 
     79   // The name of the control, like "OK" or "Password".
     80   std::string name_;
     81 
     82   // A string describing the context of the control, such as the name of
     83   // the group or toolbar it's contained in.
     84   std::string context_;
     85 };
     86 
     87 // Accessibility information about a window passed to onWindowOpened
     88 // and onWindowClosed event listeners.
     89 class AccessibilityWindowInfo : public AccessibilityControlInfo {
     90  public:
     91   AccessibilityWindowInfo(Profile* profile, const std::string& window_name);
     92 
     93   virtual const char* type() const OVERRIDE;
     94 };
     95 
     96 // Accessibility information about a push button passed to onControlFocused
     97 // and onControlAction event listeners.
     98 class AccessibilityButtonInfo : public AccessibilityControlInfo {
     99  public:
    100   AccessibilityButtonInfo(Profile* profile,
    101                           const std::string& button_name,
    102                           const std::string& context);
    103 
    104   virtual const char* type() const OVERRIDE;
    105 };
    106 
    107 // Accessibility information about a hyperlink passed to onControlFocused
    108 // and onControlAction event listeners.
    109 class AccessibilityLinkInfo : public AccessibilityControlInfo {
    110  public:
    111   AccessibilityLinkInfo(Profile* profile,
    112                         const std::string& link_name,
    113                         const std::string& context);
    114 
    115   virtual const char* type() const OVERRIDE;
    116 };
    117 
    118 // Accessibility information about a radio button passed to onControlFocused
    119 // and onControlAction event listeners.
    120 class AccessibilityRadioButtonInfo : public AccessibilityControlInfo {
    121  public:
    122   AccessibilityRadioButtonInfo(Profile* profile,
    123                                const std::string& name,
    124                                const std::string& context,
    125                                bool checked,
    126                                int item_index,
    127                                int item_count);
    128 
    129   virtual const char* type() const OVERRIDE;
    130 
    131   virtual void SerializeToDict(base::DictionaryValue* dict) const OVERRIDE;
    132 
    133   void SetChecked(bool checked) { checked_ = checked; }
    134 
    135   int item_index() const { return item_index_; }
    136   int item_count() const { return item_count_; }
    137   bool checked() const { return checked_; }
    138 
    139  private:
    140   bool checked_;
    141   // The 0-based index of this radio button and number of buttons in the group.
    142   int item_index_;
    143   int item_count_;
    144 };
    145 
    146 // Accessibility information about a checkbox passed to onControlFocused
    147 // and onControlAction event listeners.
    148 class AccessibilityCheckboxInfo : public AccessibilityControlInfo {
    149  public:
    150   AccessibilityCheckboxInfo(Profile* profile,
    151                             const std::string& name,
    152                             const std::string& context,
    153                             bool checked);
    154 
    155   virtual const char* type() const OVERRIDE;
    156 
    157   virtual void SerializeToDict(base::DictionaryValue* dict) const OVERRIDE;
    158 
    159   void SetChecked(bool checked) { checked_ = checked; }
    160 
    161   bool checked() const { return checked_; }
    162 
    163  private:
    164   bool checked_;
    165 };
    166 
    167 // Accessibility information about a tab passed to onControlFocused
    168 // and onControlAction event listeners.
    169 class AccessibilityTabInfo : public AccessibilityControlInfo {
    170  public:
    171   AccessibilityTabInfo(Profile* profile,
    172                        const std::string& tab_name,
    173                        const std::string& context,
    174                        int tab_index,
    175                        int tab_count);
    176 
    177   virtual const char* type() const OVERRIDE;
    178 
    179   virtual void SerializeToDict(base::DictionaryValue* dict) const OVERRIDE;
    180 
    181   void SetTab(int tab_index, std::string tab_name) {
    182     tab_index_ = tab_index;
    183     name_ = tab_name;
    184   }
    185 
    186   int tab_index() const { return tab_index_; }
    187   int tab_count() const { return tab_count_; }
    188 
    189  private:
    190   // The 0-based index of this tab and number of tabs in the group.
    191   int tab_index_;
    192   int tab_count_;
    193 };
    194 
    195 // Accessibility information about a combo box passed to onControlFocused
    196 // and onControlAction event listeners.
    197 class AccessibilityComboBoxInfo : public AccessibilityControlInfo {
    198  public:
    199   AccessibilityComboBoxInfo(Profile* profile,
    200                             const std::string& name,
    201                             const std::string& context,
    202                             const std::string& value,
    203                             int item_index,
    204                             int item_count);
    205 
    206   virtual const char* type() const OVERRIDE;
    207 
    208   virtual void SerializeToDict(base::DictionaryValue* dict) const OVERRIDE;
    209 
    210   void SetValue(int item_index, const std::string& value) {
    211     item_index_ = item_index;
    212     value_ = value;
    213   }
    214 
    215   int item_index() const { return item_index_; }
    216   int item_count() const { return item_count_; }
    217   const std::string& value() const { return value_; }
    218 
    219  private:
    220   std::string value_;
    221   // The 0-based index of the current item and the number of total items.
    222   // If the value is not one of the drop-down options, |item_index_| should
    223   // be -1.
    224   int item_index_;
    225   int item_count_;
    226 };
    227 
    228 
    229 // Accessibility information about a text box, passed to onControlFocused,
    230 // onControlAction, and onTextChanged event listeners.
    231 class AccessibilityTextBoxInfo : public AccessibilityControlInfo {
    232  public:
    233   AccessibilityTextBoxInfo(Profile* profile,
    234                            const std::string& name,
    235                            const std::string& context,
    236                            bool password);
    237 
    238   virtual const char* type() const OVERRIDE;
    239 
    240   virtual void SerializeToDict(base::DictionaryValue* dict) const OVERRIDE;
    241 
    242   void SetValue(
    243       const std::string& value, int selection_start, int selection_end) {
    244     value_ = value;
    245     selection_start_ = selection_start;
    246     selection_end_ = selection_end;
    247   }
    248 
    249   const std::string& value() const { return value_; }
    250   bool password() const { return password_; }
    251   int selection_start() const { return selection_start_; }
    252   int selection_end() const { return selection_end_; }
    253 
    254  private:
    255   std::string value_;
    256   bool password_;
    257   int selection_start_;
    258   int selection_end_;
    259 };
    260 
    261 // Accessibility information about a combo box passed to onControlFocused
    262 // and onControlAction event listeners.
    263 class AccessibilityListBoxInfo : public AccessibilityControlInfo {
    264  public:
    265   AccessibilityListBoxInfo(Profile* profile,
    266                            const std::string& name,
    267                            const std::string& context,
    268                            const std::string& value,
    269                            int item_index,
    270                            int item_count);
    271 
    272   virtual const char* type() const OVERRIDE;
    273 
    274   virtual void SerializeToDict(base::DictionaryValue* dict) const OVERRIDE;
    275 
    276   void SetValue(int item_index, std::string value) {
    277     item_index_ = item_index;
    278     value_ = value;
    279   }
    280 
    281   int item_index() const { return item_index_; }
    282   int item_count() const { return item_count_; }
    283   const std::string& value() const { return value_; }
    284 
    285  private:
    286   std::string value_;
    287   // The 0-based index of the current item and the number of total items.
    288   // If the value is not one of the drop-down options, |item_index_| should
    289   // be -1.
    290   int item_index_;
    291   int item_count_;
    292 };
    293 
    294 // Accessibility information about a menu; this class is used by
    295 // onMenuOpened, onMenuClosed, and onControlFocused event listeners.
    296 class AccessibilityMenuInfo : public AccessibilityControlInfo {
    297  public:
    298   AccessibilityMenuInfo(Profile* profile, const std::string& menu_name);
    299 
    300   virtual const char* type() const OVERRIDE;
    301 };
    302 
    303 // Accessibility information about a menu item; this class is used by
    304 // onControlFocused event listeners.
    305 class AccessibilityMenuItemInfo : public AccessibilityControlInfo {
    306  public:
    307   AccessibilityMenuItemInfo(Profile* profile,
    308                             const std::string& name,
    309                             const std::string& context,
    310                             bool has_submenu,
    311                             int item_index,
    312                             int item_count);
    313 
    314   virtual const char* type() const OVERRIDE;
    315 
    316   virtual void SerializeToDict(base::DictionaryValue* dict) const OVERRIDE;
    317 
    318   int item_index() const { return item_index_; }
    319   int item_count() const { return item_count_; }
    320   bool has_submenu() const { return has_submenu_; }
    321 
    322  private:
    323   bool has_submenu_;
    324   // The 0-based index of the current item and the number of total items.
    325   int item_index_;
    326   int item_count_;
    327 };
    328 
    329 // Accessibility information about a tree; this class is used by
    330 // onControlFocused event listeners.
    331 class AccessibilityTreeInfo : public AccessibilityControlInfo {
    332  public:
    333   AccessibilityTreeInfo(Profile* profile, const std::string& menu_name);
    334 
    335   virtual const char* type() const OVERRIDE;
    336 };
    337 
    338 // Accessibility information about a tree item; this class is used by
    339 // onControlFocused event listeners.
    340 class AccessibilityTreeItemInfo : public AccessibilityControlInfo {
    341  public:
    342   AccessibilityTreeItemInfo(Profile* profile,
    343                             const std::string& name,
    344                             const std::string& context,
    345                             int item_depth,
    346                             int item_index,
    347                             int item_count,
    348                             int children_count,
    349                             bool is_expanded);
    350 
    351   virtual const char* type() const OVERRIDE;
    352 
    353   virtual void SerializeToDict(base::DictionaryValue* dict) const OVERRIDE;
    354 
    355   int item_depth() const { return item_depth_; }
    356   int item_index() const { return item_index_; }
    357   int item_count() const { return item_count_; }
    358   int children_count() const { return children_count_; }
    359   bool is_expanded() const { return is_expanded_; }
    360 
    361  private:
    362   // 0-based item depth.
    363   int item_depth_;
    364   // The 0-based index of the current item and the number of total items at the
    365   // current depth.
    366   int item_index_;
    367   // Count of items at the current depth.
    368   int item_count_;
    369   // Count of children of the current item.
    370   int children_count_;
    371   // True if the node is expanded.
    372   bool is_expanded_;
    373 };
    374 
    375 // Accessibility information about a slider passed to onControlFocused
    376 // and onControlAction event listeners.
    377 class AccessibilitySliderInfo : public AccessibilityControlInfo {
    378  public:
    379   AccessibilitySliderInfo(Profile* profile,
    380                           const std::string& name,
    381                           const std::string& context,
    382                           const std::string& value);
    383 
    384   virtual const char* type() const OVERRIDE;
    385 
    386   virtual void SerializeToDict(base::DictionaryValue* dict) const OVERRIDE;
    387 
    388   const std::string& value() const { return value_; }
    389 
    390  private:
    391   std::string value_;
    392 };
    393 
    394 // Accessibility information about an alert passed to onControlAction event.
    395 class AccessibilityAlertInfo : public AccessibilityControlInfo {
    396  public:
    397   AccessibilityAlertInfo(Profile* profile, const std::string& name);
    398 
    399   virtual const char* type() const OVERRIDE;
    400 };
    401 
    402 #endif  // CHROME_BROWSER_ACCESSIBILITY_ACCESSIBILITY_EVENTS_H_
    403