accessibility_events.h revision f2477e01787aa58f445919b809d89e252beef54f 
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
12class AccessibilityControlInfo;
13class AccessibilityMenuInfo;
14class AccessibilityWindowInfo;
15class Profile;
16
17namespace base {
18class 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).
24void SendControlAccessibilityNotification(
25    ui::AccessibilityTypes::Event event,
26    AccessibilityControlInfo* info);
27
28void SendMenuAccessibilityNotification(
29    ui::AccessibilityTypes::Event event,
30    AccessibilityMenuInfo* info);
31
32void SendWindowAccessibilityNotification(
33    ui::AccessibilityTypes::Event event,
34    AccessibilityWindowInfo* info);
35
36// Abstract parent class for accessibility event information passed to event
37// listeners.
38class 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.
57class 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.
89class 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.
98class 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.
109class 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.
120class 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.
148class 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.
169class 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.
197class 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// Accessibility information about a text box, passed to onControlFocused,
229// onControlAction, and onTextChanged event listeners.
230class AccessibilityTextBoxInfo : public AccessibilityControlInfo {
231 public:
232  AccessibilityTextBoxInfo(Profile* profile,
233                           const std::string& name,
234                           const std::string& context,
235                           bool password);
236
237  virtual const char* type() const OVERRIDE;
238
239  virtual void SerializeToDict(base::DictionaryValue* dict) const OVERRIDE;
240
241  void SetValue(
242      const std::string& value, int selection_start, int selection_end) {
243    value_ = value;
244    selection_start_ = selection_start;
245    selection_end_ = selection_end;
246  }
247
248  const std::string& value() const { return value_; }
249  bool password() const { return password_; }
250  int selection_start() const { return selection_start_; }
251  int selection_end() const { return selection_end_; }
252
253 private:
254  std::string value_;
255  bool password_;
256  int selection_start_;
257  int selection_end_;
258};
259
260// Accessibility information about a combo box passed to onControlFocused
261// and onControlAction event listeners.
262class AccessibilityListBoxInfo : public AccessibilityControlInfo {
263 public:
264  AccessibilityListBoxInfo(Profile* profile,
265                           const std::string& name,
266                           const std::string& context,
267                           const std::string& value,
268                           int item_index,
269                           int item_count);
270
271  virtual const char* type() const OVERRIDE;
272
273  virtual void SerializeToDict(base::DictionaryValue* dict) const OVERRIDE;
274
275  void SetValue(int item_index, std::string value) {
276    item_index_ = item_index;
277    value_ = value;
278  }
279
280  int item_index() const { return item_index_; }
281  int item_count() const { return item_count_; }
282  const std::string& value() const { return value_; }
283
284 private:
285  std::string value_;
286  // The 0-based index of the current item and the number of total items.
287  // If the value is not one of the drop-down options, |item_index_| should
288  // be -1.
289  int item_index_;
290  int item_count_;
291};
292
293// Accessibility information about a menu; this class is used by
294// onMenuOpened, onMenuClosed, and onControlFocused event listeners.
295class AccessibilityMenuInfo : public AccessibilityControlInfo {
296 public:
297  AccessibilityMenuInfo(Profile* profile, const std::string& menu_name);
298
299  virtual const char* type() const OVERRIDE;
300};
301
302// Accessibility information about a menu item; this class is used by
303// onControlFocused event listeners.
304class AccessibilityMenuItemInfo : public AccessibilityControlInfo {
305 public:
306  AccessibilityMenuItemInfo(Profile* profile,
307                            const std::string& name,
308                            const std::string& context,
309                            bool has_submenu,
310                            int item_index,
311                            int item_count);
312
313  virtual const char* type() const OVERRIDE;
314
315  virtual void SerializeToDict(base::DictionaryValue* dict) const OVERRIDE;
316
317  int item_index() const { return item_index_; }
318  int item_count() const { return item_count_; }
319  bool has_submenu() const { return has_submenu_; }
320
321 private:
322  bool has_submenu_;
323  // The 0-based index of the current item and the number of total items.
324  int item_index_;
325  int item_count_;
326};
327
328// Accessibility information about a slider passed to onControlFocused
329// and onControlAction event listeners.
330class AccessibilitySliderInfo : public AccessibilityControlInfo {
331 public:
332  AccessibilitySliderInfo(Profile* profile,
333                          const std::string& name,
334                          const std::string& context,
335                          const std::string& value);
336
337  virtual const char* type() const OVERRIDE;
338
339  virtual void SerializeToDict(base::DictionaryValue* dict) const OVERRIDE;
340
341  const std::string& value() const { return value_; }
342
343 private:
344  std::string value_;
345};
346
347// Accessibility information about an alert passed to onControlAction event.
348class AccessibilityAlertInfo : public AccessibilityControlInfo {
349 public:
350  AccessibilityAlertInfo(Profile* profile, const std::string& name);
351
352  virtual const char* type() const OVERRIDE;
353};
354
355#endif  // CHROME_BROWSER_ACCESSIBILITY_ACCESSIBILITY_EVENTS_H_
356