1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef UI_VIEWS_ACCESSIBILITY_VIEW_ACCESSIBILITY_H_
#define UI_VIEWS_ACCESSIBILITY_VIEW_ACCESSIBILITY_H_
#include <memory>
#include <string>
#include "base/macros.h"
#include "base/strings/string16.h"
#include "build/build_config.h"
#include "ui/accessibility/ax_enums.mojom.h"
#include "ui/accessibility/ax_node_data.h"
#include "ui/accessibility/platform/ax_unique_id.h"
#include "ui/gfx/native_widget_types.h"
#include "ui/views/accessibility/ax_virtual_view.h"
#include "ui/views/views_export.h"
namespace views {
class View;
// An object that manages the accessibility interface for a View.
//
// The default accessibility properties of a View is determined by calling
// |View::GetAccessibleNodeData()|, which is overridden by many |View|
// subclasses. |ViewAccessibility| lets you override these for a particular
// view.
//
// In most cases, subclasses of |ViewAccessibility| own the |AXPlatformNode|
// that implements the native accessibility APIs on a specific platform.
class VIEWS_EXPORT ViewAccessibility {
public:
static std::unique_ptr<ViewAccessibility> Create(View* view);
virtual ~ViewAccessibility();
// Modifies |node_data| to reflect the current accessible state of the
// associated View, taking any custom overrides into account
// (see OverrideRole, etc. below).
virtual void GetAccessibleNodeData(ui::AXNodeData* node_data) const;
//
// These override accessibility information, including properties returned
// from View::GetAccessibleNodeData().
// Note that string attributes are only used if non-empty, so you can't
// override a string with the empty string.
//
// Sets one of our virtual descendants as having the accessibility focus. This
// means that if this view has the system focus, it will set the accessibility
// focus to the provided descendant virtual view instead. Set this to nullptr
// if none of our virtual descendants should have the accessibility focus. It
// is illegal to set this to any virtual view that is currently not one of our
// descendants and this is enforced by a DCHECK.
void OverrideFocus(AXVirtualView* virtual_view);
void OverrideRole(const ax::mojom::Role role);
void OverrideName(const std::string& name);
void OverrideName(const base::string16& name);
void OverrideDescription(const std::string& description);
void OverrideDescription(const base::string16& description);
void OverrideIsLeaf(bool value);
void OverrideIsIgnored(bool value);
virtual gfx::NativeViewAccessible GetNativeObject();
virtual void NotifyAccessibilityEvent(ax::mojom::Event event_type) {}
#if defined(OS_MACOSX)
virtual void AnnounceText(base::string16& text) {}
#endif
virtual const ui::AXUniqueId& GetUniqueId() const;
View* view() const { return view_; }
AXVirtualView* FocusedVirtualChild() const { return focused_virtual_child_; }
bool IsLeaf() const { return is_leaf_; }
bool IsIgnored() const { return is_ignored_; }
//
// Methods for managing virtual views.
//
// Adds |virtual_view| as a child of this View, optionally at |index|.
// We take ownership of our virtual children.
void AddVirtualChildView(std::unique_ptr<AXVirtualView> virtual_view);
void AddVirtualChildViewAt(std::unique_ptr<AXVirtualView> virtual_view,
int index);
// Removes |virtual_view| from this View. The virtual view's parent will
// change to nullptr. Hands ownership back to the caller.
std::unique_ptr<AXVirtualView> RemoveVirtualChildView(
AXVirtualView* virtual_view);
// Removes all the virtual children from this View.
// The virtual views are deleted.
void RemoveAllVirtualChildViews();
int virtual_child_count() const {
return static_cast<int>(virtual_children_.size());
}
const AXVirtualView* virtual_child_at(int index) const {
DCHECK_GE(index, 0);
DCHECK_LT(index, virtual_child_count());
return virtual_children_[index].get();
}
// Returns true if |virtual_view| is contained within the hierarchy of this
// View, even as an indirect descendant.
bool Contains(const AXVirtualView* virtual_view) const;
// Returns the index of |virtual_view|, or -1 if |virtual_view| is not a child
// of this View.
int GetIndexOf(const AXVirtualView* virtual_view) const;
// Returns the native accessibility object associated with the AXVirtualView
// descendant that is currently focused. If no virtual descendants are
// present, or no virtual descendant has been marked as focused, returns the
// native accessibility object associated with this view.
gfx::NativeViewAccessible GetFocusedDescendant();
protected:
explicit ViewAccessibility(View* view);
private:
// Weak. Owns this.
View* const view_;
// If there are any virtual children, they override any real children.
// We own our virtual children.
std::vector<std::unique_ptr<AXVirtualView>> virtual_children_;
// The virtual child that is currently focused.
// This is nullptr if no virtual child is focused.
// See also OverrideFocus() and GetFocusedDescendant().
AXVirtualView* focused_virtual_child_;
const ui::AXUniqueId unique_id_;
// Contains data set explicitly via OverrideRole, OverrideName, etc. that
// overrides anything provided by GetAccessibleNodeData().
ui::AXNodeData custom_data_;
// If set to true, anything that is a descendant of this view will be hidden
// from accessibility.
bool is_leaf_;
// When true the view is ignored when generating the AX node hierarchy, but
// its children are included. For example, if you created a custom table with
// the digits 1 - 9 arranged in a 3 x 3 grid, marking the table and rows
// "ignored" would mean that the digits 1 - 9 would appear as if they were
// immediate children of the root. Likewise "internal" container views can be
// ignored, like a Widget's RootView, ClientView, etc.
// Similar to setting the role of an ARIA widget to "none" or
// "presentational".
bool is_ignored_;
DISALLOW_COPY_AND_ASSIGN(ViewAccessibility);
};
} // namespace views
#endif // UI_VIEWS_ACCESSIBILITY_VIEW_ACCESSIBILITY_H_
|
