| // 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 <vector> |
| |
| #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); |
| void OverrideBounds(const gfx::RectF& bounds); |
| |
| // Override indexes used by some screen readers when describing elements in a |
| // menu, list, etc. If not specified, a view's index in its parent and its |
| // parent's number of children provide the values for these. |
| // |
| // Note: |pos_in_set| is 1-indexed. |
| void OverridePosInSet(int pos_in_set, int set_size); |
| |
| 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()); |
| } |
| |
| AXVirtualView* virtual_child_at(int index) { |
| return const_cast<AXVirtualView*>( |
| const_cast<const ViewAccessibility*>(this)->virtual_child_at(index)); |
| } |
| |
| 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_ |