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