| // Copyright (c) 2012 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 CONTENT_BROWSER_ACCESSIBILITY_BROWSER_ACCESSIBILITY_MANAGER_H_ |
| #define CONTENT_BROWSER_ACCESSIBILITY_BROWSER_ACCESSIBILITY_MANAGER_H_ |
| |
| #include <vector> |
| |
| #include "base/containers/hash_tables.h" |
| #include "base/memory/scoped_ptr.h" |
| #include "build/build_config.h" |
| #include "content/common/content_export.h" |
| #include "third_party/WebKit/public/web/WebAXEnums.h" |
| #include "ui/accessibility/ax_node_data.h" |
| #include "ui/accessibility/ax_tree.h" |
| #include "ui/accessibility/ax_tree_update.h" |
| #include "ui/gfx/native_widget_types.h" |
| |
| struct AccessibilityHostMsg_EventParams; |
| struct AccessibilityHostMsg_LocationChangeParams; |
| |
| namespace content { |
| class BrowserAccessibility; |
| #if defined(OS_ANDROID) |
| class BrowserAccessibilityManagerAndroid; |
| #endif |
| #if defined(OS_WIN) |
| class BrowserAccessibilityManagerWin; |
| #endif |
| |
| // For testing. |
| CONTENT_EXPORT ui::AXTreeUpdate MakeAXTreeUpdate( |
| const ui::AXNodeData& node, |
| const ui::AXNodeData& node2 = ui::AXNodeData(), |
| const ui::AXNodeData& node3 = ui::AXNodeData(), |
| const ui::AXNodeData& node4 = ui::AXNodeData(), |
| const ui::AXNodeData& node5 = ui::AXNodeData(), |
| const ui::AXNodeData& node6 = ui::AXNodeData(), |
| const ui::AXNodeData& node7 = ui::AXNodeData(), |
| const ui::AXNodeData& node8 = ui::AXNodeData(), |
| const ui::AXNodeData& node9 = ui::AXNodeData()); |
| |
| // Class that can perform actions on behalf of the BrowserAccessibilityManager. |
| class CONTENT_EXPORT BrowserAccessibilityDelegate { |
| public: |
| virtual ~BrowserAccessibilityDelegate() {} |
| virtual void AccessibilitySetFocus(int acc_obj_id) = 0; |
| virtual void AccessibilityDoDefaultAction(int acc_obj_id) = 0; |
| virtual void AccessibilityShowMenu(int acc_obj_id) = 0; |
| virtual void AccessibilityScrollToMakeVisible( |
| int acc_obj_id, gfx::Rect subfocus) = 0; |
| virtual void AccessibilityScrollToPoint( |
| int acc_obj_id, gfx::Point point) = 0; |
| virtual void AccessibilitySetTextSelection( |
| int acc_obj_id, int start_offset, int end_offset) = 0; |
| virtual bool AccessibilityViewHasFocus() const = 0; |
| virtual gfx::Rect AccessibilityGetViewBounds() const = 0; |
| virtual gfx::Point AccessibilityOriginInScreen( |
| const gfx::Rect& bounds) const = 0; |
| virtual void AccessibilityHitTest( |
| const gfx::Point& point) = 0; |
| virtual void AccessibilityFatalError() = 0; |
| }; |
| |
| class CONTENT_EXPORT BrowserAccessibilityFactory { |
| public: |
| virtual ~BrowserAccessibilityFactory() {} |
| |
| // Create an instance of BrowserAccessibility and return a new |
| // reference to it. |
| virtual BrowserAccessibility* Create(); |
| }; |
| |
| // Manages a tree of BrowserAccessibility objects. |
| class CONTENT_EXPORT BrowserAccessibilityManager : public ui::AXTreeDelegate { |
| public: |
| // Creates the platform-specific BrowserAccessibilityManager, but |
| // with no parent window pointer. Only useful for unit tests. |
| static BrowserAccessibilityManager* Create( |
| const ui::AXTreeUpdate& initial_tree, |
| BrowserAccessibilityDelegate* delegate, |
| BrowserAccessibilityFactory* factory = new BrowserAccessibilityFactory()); |
| |
| virtual ~BrowserAccessibilityManager(); |
| |
| void Initialize(const ui::AXTreeUpdate& initial_tree); |
| |
| static ui::AXTreeUpdate GetEmptyDocument(); |
| |
| virtual void NotifyAccessibilityEvent( |
| ui::AXEvent event_type, BrowserAccessibility* node) { } |
| |
| // Return a pointer to the root of the tree, does not make a new reference. |
| BrowserAccessibility* GetRoot(); |
| |
| // Returns a pointer to the BrowserAccessibility object for a given AXNode. |
| BrowserAccessibility* GetFromAXNode(ui::AXNode* node); |
| |
| // Return a pointer to the object corresponding to the given id, |
| // does not make a new reference. |
| BrowserAccessibility* GetFromID(int32 id); |
| |
| // Called to notify the accessibility manager that its associated native |
| // view got focused. |
| virtual void OnWindowFocused(); |
| |
| // Called to notify the accessibility manager that its associated native |
| // view lost focus. |
| virtual void OnWindowBlurred(); |
| |
| // Called to notify the accessibility manager that a mouse down event |
| // occurred in the tab. |
| void GotMouseDown(); |
| |
| // Update the focused node to |node|, which may be null. |
| // If |notify| is true, send a message to the renderer to set focus |
| // to this node. |
| void SetFocus(ui::AXNode* node, bool notify); |
| void SetFocus(BrowserAccessibility* node, bool notify); |
| |
| // Tell the renderer to do the default action for this node. |
| void DoDefaultAction(const BrowserAccessibility& node); |
| |
| // Tell the renderer to scroll to make |node| visible. |
| // In addition, if it's not possible to make the entire object visible, |
| // scroll so that the |subfocus| rect is visible at least. The subfocus |
| // rect is in local coordinates of the object itself. |
| void ScrollToMakeVisible( |
| const BrowserAccessibility& node, gfx::Rect subfocus); |
| |
| // Tell the renderer to scroll such that |node| is at |point|, |
| // where |point| is in global coordinates of the WebContents. |
| void ScrollToPoint( |
| const BrowserAccessibility& node, gfx::Point point); |
| |
| // Tell the renderer to set the text selection on a node. |
| void SetTextSelection( |
| const BrowserAccessibility& node, int start_offset, int end_offset); |
| |
| // Retrieve the bounds of the parent View in screen coordinates. |
| gfx::Rect GetViewBounds(); |
| |
| // Called when the renderer process has notified us of about tree changes. |
| void OnAccessibilityEvents( |
| const std::vector<AccessibilityHostMsg_EventParams>& params); |
| |
| // Called when the renderer process updates the location of accessibility |
| // objects. |
| void OnLocationChanges( |
| const std::vector<AccessibilityHostMsg_LocationChangeParams>& params); |
| |
| #if defined(OS_WIN) |
| BrowserAccessibilityManagerWin* ToBrowserAccessibilityManagerWin(); |
| #endif |
| |
| #if defined(OS_ANDROID) |
| BrowserAccessibilityManagerAndroid* ToBrowserAccessibilityManagerAndroid(); |
| #endif |
| |
| // Return the object that has focus, if it's a descandant of the |
| // given root (inclusive). Does not make a new reference. |
| virtual BrowserAccessibility* GetFocus(BrowserAccessibility* root); |
| |
| // Return the descentant of the given root that has focus, or that object's |
| // active descendant if it has one. |
| BrowserAccessibility* GetActiveDescendantFocus(BrowserAccessibility* root); |
| |
| // True by default, but some platforms want to treat the root |
| // scroll offsets separately. |
| virtual bool UseRootScrollOffsetsWhenComputingBounds(); |
| |
| // Walk the tree. |
| BrowserAccessibility* NextInTreeOrder(BrowserAccessibility* node); |
| BrowserAccessibility* PreviousInTreeOrder(BrowserAccessibility* node); |
| |
| // AXTreeDelegate implementation. |
| virtual void OnNodeWillBeDeleted(ui::AXNode* node) OVERRIDE; |
| virtual void OnNodeCreated(ui::AXNode* node) OVERRIDE; |
| virtual void OnNodeChanged(ui::AXNode* node) OVERRIDE; |
| virtual void OnNodeCreationFinished(ui::AXNode* node) OVERRIDE; |
| virtual void OnNodeChangeFinished(ui::AXNode* node) OVERRIDE; |
| virtual void OnRootChanged(ui::AXNode* new_root) OVERRIDE {} |
| |
| BrowserAccessibilityDelegate* delegate() const { return delegate_; } |
| |
| protected: |
| BrowserAccessibilityManager( |
| BrowserAccessibilityDelegate* delegate, |
| BrowserAccessibilityFactory* factory); |
| |
| BrowserAccessibilityManager( |
| const ui::AXTreeUpdate& initial_tree, |
| BrowserAccessibilityDelegate* delegate, |
| BrowserAccessibilityFactory* factory); |
| |
| // Called at the end of updating the tree. |
| virtual void OnTreeUpdateFinished() {} |
| |
| private: |
| // The following states keep track of whether or not the |
| // on-screen keyboard is allowed to be shown. |
| enum OnScreenKeyboardState { |
| // Never show the on-screen keyboard because this tab is hidden. |
| OSK_DISALLOWED_BECAUSE_TAB_HIDDEN, |
| |
| // This tab was just shown, so don't pop-up the on-screen keyboard if a |
| // text field gets focus that wasn't the result of an explicit touch. |
| OSK_DISALLOWED_BECAUSE_TAB_JUST_APPEARED, |
| |
| // A touch event has occurred within the window, but focus has not |
| // explicitly changed. Allow the on-screen keyboard to be shown if the |
| // touch event was within the bounds of the currently focused object. |
| // Otherwise we'll just wait to see if focus changes. |
| OSK_ALLOWED_WITHIN_FOCUSED_OBJECT, |
| |
| // Focus has changed within a tab that's already visible. Allow the |
| // on-screen keyboard to show anytime that a touch event leads to an |
| // editable text control getting focus. |
| OSK_ALLOWED |
| }; |
| |
| // Update a set of nodes using data received from the renderer |
| // process. |
| bool UpdateNodes(const std::vector<ui::AXNodeData>& nodes); |
| |
| // Update one node from the tree using data received from the renderer |
| // process. Returns true on success, false on fatal error. |
| bool UpdateNode(const ui::AXNodeData& src); |
| |
| void SetRoot(BrowserAccessibility* root); |
| |
| BrowserAccessibility* CreateNode( |
| BrowserAccessibility* parent, |
| int32 id, |
| int32 index_in_parent); |
| |
| protected: |
| // The object that can perform actions on our behalf. |
| BrowserAccessibilityDelegate* delegate_; |
| |
| // Factory to create BrowserAccessibility objects (for dependency injection). |
| scoped_ptr<BrowserAccessibilityFactory> factory_; |
| |
| // The underlying tree of accessibility objects. |
| scoped_ptr<ui::AXTree> tree_; |
| |
| // The node that currently has focus. |
| ui::AXNode* focus_; |
| |
| // A mapping from a node id to its wrapper of type BrowserAccessibility. |
| base::hash_map<int32, BrowserAccessibility*> id_wrapper_map_; |
| |
| // The on-screen keyboard state. |
| OnScreenKeyboardState osk_state_; |
| |
| DISALLOW_COPY_AND_ASSIGN(BrowserAccessibilityManager); |
| }; |
| |
| } // namespace content |
| |
| #endif // CONTENT_BROWSER_ACCESSIBILITY_BROWSER_ACCESSIBILITY_MANAGER_H_ |