chrome/browser/accessibility/accessibility_events.cc

   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 #include "chrome/browser/accessibility/accessibility_events.h"
   6
   7 #include "base/values.h"
   8 #include "chrome/browser/accessibility/accessibility_extension_api.h"
   9 #include "chrome/browser/accessibility/accessibility_extension_api_constants.h"
  10 #include "chrome/browser/chrome_notification_types.h"
  11 #include "chrome/browser/profiles/profile.h"
  12 #include "chrome/browser/profiles/profile_manager.h"
  13 #include "content/public/browser/notification_service.h"
  14 #include "content/public/browser/notification_types.h"
  15
  16 namespace keys = extension_accessibility_api_constants;
  17
  18 void SendControlAccessibilityNotification(
  19   ui::AccessibilityTypes::Event event,
  20   AccessibilityControlInfo* info) {
  21   Profile *profile = info->profile();
  22   if (profile->ShouldSendAccessibilityEvents()) {
  23     ExtensionAccessibilityEventRouter::GetInstance()->HandleControlEvent(
  24         event,
  25         info);
  26   }
  27 }
  28
  29 void SendMenuAccessibilityNotification(
  30   ui::AccessibilityTypes::Event event,
  31   AccessibilityMenuInfo* info) {
  32   Profile *profile = info->profile();
  33   if (profile->ShouldSendAccessibilityEvents()) {
  34     ExtensionAccessibilityEventRouter::GetInstance()->HandleMenuEvent(
  35         event,
  36         info);
  37   }
  38 }
  39
  40 void SendWindowAccessibilityNotification(
  41   ui::AccessibilityTypes::Event event,
  42   AccessibilityWindowInfo* info) {
  43   Profile *profile = info->profile();
  44   if (profile->ShouldSendAccessibilityEvents()) {
  45     ExtensionAccessibilityEventRouter::GetInstance()->HandleWindowEvent(
  46         event,
  47         info);
  48   }
  49 }
  50
  51
  52 AccessibilityControlInfo::AccessibilityControlInfo(
  53     Profile* profile, const std::string& name)
  54     : AccessibilityEventInfo(profile),
  55       name_(name) {
  56 }
  57
  58 AccessibilityControlInfo::~AccessibilityControlInfo() {
  59 }
  60
  61 void AccessibilityControlInfo::SerializeToDict(DictionaryValue *dict) const {
  62   dict->SetString(keys::kNameKey, name_);
  63   dict->SetString(keys::kTypeKey, type());
  64   if (!context_.empty())
  65     dict->SetString(keys::kContextKey, context_);
  66 }
  67
  68 AccessibilityWindowInfo::AccessibilityWindowInfo(Profile* profile,
  69                                                  const std::string& window_name)
  70     : AccessibilityControlInfo(profile, window_name) {
  71 }
  72
  73 const char* AccessibilityWindowInfo::type() const {
  74   return keys::kTypeWindow;
  75 }
  76
  77 AccessibilityButtonInfo::AccessibilityButtonInfo(Profile* profile,
  78                                                  const std::string& button_name,
  79                                                  const std::string& context)
  80     : AccessibilityControlInfo(profile, button_name) {
  81   set_context(context);
  82 }
  83
  84 const char* AccessibilityButtonInfo::type() const {
  85   return keys::kTypeButton;
  86 }
  87
  88 AccessibilityLinkInfo::AccessibilityLinkInfo(Profile* profile,
  89                                              const std::string& link_name,
  90                                              const std::string& context)
  91     : AccessibilityControlInfo(profile, link_name) {
  92   set_context(context);
  93 }
  94
  95 const char* AccessibilityLinkInfo::type() const {
  96   return keys::kTypeLink;
  97 }
  98
  99 AccessibilityRadioButtonInfo::AccessibilityRadioButtonInfo(
 100     Profile* profile,
 101     const std::string& name,
 102     const std::string& context,
 103     bool checked,
 104     int item_index,
 105     int item_count)
 106     : AccessibilityControlInfo(profile, name),
 107       checked_(checked),
 108       item_index_(item_index),
 109       item_count_(item_count) {
 110   set_context(context);
 111 }
 112
 113 const char* AccessibilityRadioButtonInfo::type() const {
 114   return keys::kTypeRadioButton;
 115 }
 116
 117 void AccessibilityRadioButtonInfo::SerializeToDict(
 118     DictionaryValue *dict) const {
 119   AccessibilityControlInfo::SerializeToDict(dict);
 120   dict->SetBoolean(keys::kCheckedKey, checked_);
 121   dict->SetInteger(keys::kItemIndexKey, item_index_);
 122   dict->SetInteger(keys::kItemCountKey, item_count_);
 123 }
 124
 125 AccessibilityCheckboxInfo::AccessibilityCheckboxInfo(Profile* profile,
 126                                                      const std::string& name,
 127                                                      const std::string& context,
 128                                                      bool checked)
 129     : AccessibilityControlInfo(profile, name),
 130       checked_(checked) {
 131   set_context(context);
 132 }
 133
 134 const char* AccessibilityCheckboxInfo::type() const {
 135   return keys::kTypeCheckbox;
 136 }
 137
 138 void AccessibilityCheckboxInfo::SerializeToDict(DictionaryValue *dict) const {
 139   AccessibilityControlInfo::SerializeToDict(dict);
 140   dict->SetBoolean(keys::kCheckedKey, checked_);
 141 }
 142
 143 AccessibilityTabInfo::AccessibilityTabInfo(Profile* profile,
 144                                            const std::string& tab_name,
 145                                            const std::string& context,
 146                                            int tab_index,
 147                                            int tab_count)
 148     : AccessibilityControlInfo(profile, tab_name),
 149       tab_index_(tab_index),
 150       tab_count_(tab_count) {
 151   set_context(context);
 152 }
 153
 154 const char* AccessibilityTabInfo::type() const {
 155   return keys::kTypeTab;
 156 }
 157
 158 void AccessibilityTabInfo::SerializeToDict(DictionaryValue *dict) const {
 159   AccessibilityControlInfo::SerializeToDict(dict);
 160   dict->SetInteger(keys::kItemIndexKey, tab_index_);
 161   dict->SetInteger(keys::kItemCountKey, tab_count_);
 162 }
 163
 164 AccessibilityComboBoxInfo::AccessibilityComboBoxInfo(Profile* profile,
 165                                                      const std::string& name,
 166                                                      const std::string& context,
 167                                                      const std::string& value,
 168                                                      int item_index,
 169                                                      int item_count)
 170     : AccessibilityControlInfo(profile, name),
 171       value_(value),
 172       item_index_(item_index),
 173       item_count_(item_count) {
 174   set_context(context);
 175 }
 176
 177 const char* AccessibilityComboBoxInfo::type() const {
 178   return keys::kTypeComboBox;
 179 }
 180
 181 void AccessibilityComboBoxInfo::SerializeToDict(DictionaryValue *dict) const {
 182   AccessibilityControlInfo::SerializeToDict(dict);
 183   dict->SetString(keys::kValueKey, value_);
 184   dict->SetInteger(keys::kItemIndexKey, item_index_);
 185   dict->SetInteger(keys::kItemCountKey, item_count_);
 186 }
 187
 188 AccessibilityTextBoxInfo::AccessibilityTextBoxInfo(Profile* profile,
 189                                                    const std::string& name,
 190                                                    const std::string& context,
 191                                                    bool password)
 192     : AccessibilityControlInfo(profile, name),
 193       password_(password),
 194       selection_start_(0),
 195       selection_end_(0) {
 196   set_context(context);
 197 }
 198
 199 const char* AccessibilityTextBoxInfo::type() const {
 200   return keys::kTypeTextBox;
 201 }
 202
 203 void AccessibilityTextBoxInfo::SerializeToDict(DictionaryValue *dict) const {
 204   AccessibilityControlInfo::SerializeToDict(dict);
 205   dict->SetString(keys::kValueKey, value_);
 206   dict->SetBoolean(keys::kPasswordKey, password_);
 207   dict->SetInteger(keys::kSelectionStartKey, selection_start_);
 208   dict->SetInteger(keys::kSelectionEndKey, selection_end_);
 209 }
 210
 211 AccessibilityListBoxInfo::AccessibilityListBoxInfo(Profile* profile,
 212                                                    const std::string& name,
 213                                                    const std::string& context,
 214                                                    const std::string& value,
 215                                                    int item_index,
 216                                                    int item_count)
 217     : AccessibilityControlInfo(profile, name),
 218       value_(value),
 219       item_index_(item_index),
 220       item_count_(item_count) {
 221   set_context(context);
 222 }
 223
 224 const char* AccessibilityListBoxInfo::type() const {
 225   return keys::kTypeListBox;
 226 }
 227
 228 void AccessibilityListBoxInfo::SerializeToDict(DictionaryValue *dict) const {
 229   AccessibilityControlInfo::SerializeToDict(dict);
 230   dict->SetString(keys::kValueKey, value_);
 231   dict->SetInteger(keys::kItemIndexKey, item_index_);
 232   dict->SetInteger(keys::kItemCountKey, item_count_);
 233 }
 234
 235 AccessibilityMenuInfo::AccessibilityMenuInfo(Profile* profile,
 236                                              const std::string& menu_name)
 237     : AccessibilityControlInfo(profile, menu_name) {
 238 }
 239
 240 const char* AccessibilityMenuInfo::type() const {
 241   return keys::kTypeMenu;
 242 }
 243
 244 AccessibilityMenuItemInfo::AccessibilityMenuItemInfo(Profile* profile,
 245                                                      const std::string& name,
 246                                                      const std::string& context,
 247                                                      bool has_submenu,
 248                                                      int item_index,
 249                                                      int item_count)
 250     : AccessibilityControlInfo(profile, name),
 251       has_submenu_(has_submenu),
 252       item_index_(item_index),
 253       item_count_(item_count) {
 254   set_context(context);
 255 }
 256
 257 const char* AccessibilityMenuItemInfo::type() const {
 258   return keys::kTypeMenuItem;
 259 }
 260
 261 void AccessibilityMenuItemInfo::SerializeToDict(DictionaryValue *dict) const {
 262   AccessibilityControlInfo::SerializeToDict(dict);
 263   dict->SetBoolean(keys::kHasSubmenuKey, has_submenu_);
 264   dict->SetInteger(keys::kItemIndexKey, item_index_);
 265   dict->SetInteger(keys::kItemCountKey, item_count_);
 266 }
 267
 268 AccessibilityTreeInfo::AccessibilityTreeInfo(Profile* profile,
 269                                              const std::string& menu_name)
 270     : AccessibilityControlInfo(profile, menu_name) {
 271 }
 272
 273 const char* AccessibilityTreeInfo::type() const {
 274   return keys::kTypeTree;
 275 }
 276
 277 AccessibilityTreeItemInfo::AccessibilityTreeItemInfo(Profile* profile,
 278                                                      const std::string& name,
 279                                                      const std::string& context,
 280                                                      int item_depth,
 281                                                      int item_index,
 282                                                      int item_count,
 283                                                      int children_count,
 284                                                      bool is_expanded)
 285     : AccessibilityControlInfo(profile, name),
 286       item_depth_(item_depth),
 287       item_index_(item_index),
 288       item_count_(item_count),
 289       children_count_(children_count),
 290       is_expanded_(is_expanded) {
 291   set_context(context);
 292 }
 293
 294 const char* AccessibilityTreeItemInfo::type() const {
 295   return keys::kTypeTreeItem;
 296 }
 297
 298 void AccessibilityTreeItemInfo::SerializeToDict(DictionaryValue *dict) const {
 299   AccessibilityControlInfo::SerializeToDict(dict);
 300   dict->SetInteger(keys::kItemDepthKey, item_depth_);
 301   dict->SetInteger(keys::kItemIndexKey, item_index_);
 302   dict->SetInteger(keys::kItemCountKey, item_count_);
 303   dict->SetInteger(keys::kChildrenCountKey, children_count_);
 304   dict->SetBoolean(keys::kItemExpandedKey, is_expanded_);
 305 }
 306
 307 AccessibilitySliderInfo::AccessibilitySliderInfo(Profile* profile,
 308                                                  const std::string& name,
 309                                                  const std::string& context,
 310                                                  const std::string& value)
 311     : AccessibilityControlInfo(profile, name),
 312       value_(value) {
 313   set_context(context);
 314 }
 315
 316 const char* AccessibilitySliderInfo::type() const {
 317   return keys::kTypeSlider;
 318 }
 319
 320 void AccessibilitySliderInfo::SerializeToDict(DictionaryValue *dict) const {
 321   AccessibilityControlInfo::SerializeToDict(dict);
 322   dict->SetString(keys::kStringValueKey, value_);
 323 }
 324
 325 AccessibilityAlertInfo::AccessibilityAlertInfo(Profile* profile,
 326                                                const std::string& name)
 327     : AccessibilityControlInfo(profile, name) {
 328 }
 329
 330 const char* AccessibilityAlertInfo::type() const {
 331   return keys::kTypeAlert;
 332 }