Swipe Gestures for Accessibility

ui/chromeos/touch_exploration_controller.h

 // Copyright 2014 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_CHROMEOS_TOUCH_EXPLORATION_CONTROLLER_H_
 #define UI_CHROMEOS_TOUCH_EXPLORATION_CONTROLLER_H_
 
 #include "base/timer/timer.h"
 #include "base/values.h"
 #include "ui/chromeos/ui_chromeos_export.h"
 #include "ui/events/event.h"
 #include "ui/events/event_rewriter.h"
 #include "ui/events/gesture_detection/gesture_detector.h"
+#include "ui/events/gestures/gesture_provider_aura.h"
 #include "ui/gfx/geometry/point.h"
 
 namespace aura {
 class Window;
 }
 
 namespace ui {
 
 class Event;
 class EventHandler;
+class GestureEvent;
+class GestureProviderAura;
 class TouchEvent;
 
 // TouchExplorationController is used in tandem with "Spoken Feedback" to

[dmazzoni, 2014/06/23 18:37:26]

Be sure to update this top comment to talk about gestures and mapping them to
keys

 // make the touch UI accessible.
 //
 // ** Short version **
 //
 // At a high-level, single-finger events are used for accessibility -
 // exploring the screen gets turned into mouse moves (which can then be
 // spoken by an accessibility service running), a double-tap simulates a
 // click, and gestures can be used to send high-level accessibility commands.
 // When two or more fingers are pressed initially, from then on the events
 // are passed through, but with the initial finger removed - so if you swipe
@@ skipping 35 matching lines @@
 // continue to pass through events, allowing the user to start a scroll
 // with two fingers but finish it with one. Sometimes this requires rewriting
 // the touch ids.
 //
 // Once either touch exploration or passthrough mode has been activated,
 // it remains in that mode until all fingers have been released.
 //
 // The caller is expected to retain ownership of instances of this class and
 // destroy them before |root_window| is destroyed.
 class UI_CHROMEOS_EXPORT TouchExplorationController :
-    public ui::EventRewriter {
+ public ui::EventRewriter, public ui::GestureProviderAuraClient {
  public:
   explicit TouchExplorationController(aura::Window* root_window);
   virtual ~TouchExplorationController();
 
   void CallTapTimerNowForTesting();
   void SetEventHandlerForTesting(ui::EventHandler* event_handler_for_testing);
   bool IsInNoFingersDownStateForTesting() const;
 
  private:
   // Overridden from ui::EventRewriter
   virtual ui::EventRewriteStatus RewriteEvent(
       const ui::Event& event,
       scoped_ptr<ui::Event>* rewritten_event) OVERRIDE;
   virtual ui::EventRewriteStatus NextDispatchEvent(
       const ui::Event& last_event, scoped_ptr<ui::Event>* new_event) OVERRIDE;
 
   // Event handlers based on the current state - see State, below.
   ui::EventRewriteStatus InNoFingersDown(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InSingleTapPressed(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InSingleTapReleased(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InDoubleTapPressed(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InTouchExploration(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
+  ui::EventRewriteStatus InGestureInProgress(
+      const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InPassthroughMinusOne(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InTouchExploreSecondPress(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
+
   // This timer is started every time we get the first press event, and
   // it fires after the double-click timeout elapses (300 ms by default).
   // If the user taps and releases within 300 ms and doesn't press again,
   // we treat that as a single mouse move (touch exploration) event.
   void OnTapTimerFired();
 
   // Dispatch a new event outside of the event rewriting flow.
   void DispatchEvent(ui::Event* event);
 
+  // Overridden from GestureProviderAuraClient.
+  //
+  // The gesture provider keeps track of all the touch events after
+  // the user moves fast enough to trigger a gesture. After the user
+  // completes their gesture, this method will decide what keyboard
+  // input their gesture corresponded to.
+  void OnGestureEvent(ui::GestureEvent* gesture) OVERRIDE;
+
+  void OnSwipeEvent(ui::GestureEvent* swipe_gesture);
+
+  // Dispatches the keyboard short cut Shift+Search+<arrow key>
+  // outside the event rewritting flow.
+  void DispatchShiftSearchKeyEvent(const ui::KeyboardCode direction);
+
   scoped_ptr<ui::Event> CreateMouseMoveEvent(const gfx::PointF& location,
                                              int flags);
 
   void EnterTouchToMouseMode();
 
   // Set the state to NO_FINGERS_DOWN and reset any other fields to their
   // default value.
   void ResetToNoFingersDown();
 
   enum State {
@@ skipping 15 matching lines @@
     DOUBLE_TAP_PRESSED,
 
     // We're in touch exploration mode. Anything other than the first finger
     // is ignored, and movements of the first finger are rewritten as mouse
     // move events. This mode is entered if a single finger is pressed and
     // after the grace period the user hasn't added a second finger or
     // moved the finger outside of the slop region. We'll stay in this
     // mode until all fingers are lifted.
     TOUCH_EXPLORATION,
 
+    // If the user moves their finger faster than the threshold velocity after a
+    // single tap, the touch events that follow will be translated into gesture
+    // events. If the user successfully completes a gesture within the grace
+    // period, the gesture will be collected and sent to the GestureClient.
+    // Otherwise, the collected gestures are discarded and the state changes to
+    // touch_exploration.
+    GESTURE_IN_PROGRESS,
+
     // The user placed two or more fingers down within the grace period.
     // We're now in passthrough mode until all fingers are lifted. Initially
     // the first finger is ignored and other fingers are passed through
     // as-is. If a finger other than the initial one is the first to be
     // released, we rewrite the first finger with the touch id of the finger
     // that was released, from now on. The motivation for this is that if
     // the user starts a scroll with 2 fingers, they can release either one
     // and continue the scrolling.
     PASSTHROUGH_MINUS_ONE,
 
@@ skipping 42 matching lines @@
   base::OneShotTimer<TouchExplorationController> tap_timer_;
 
   // For testing only, an event handler to use for generated events
   // outside of the normal event rewriting flow.
   ui::EventHandler* event_handler_for_testing_;
 
   // A default gesture detector config, so we can share the same
   // timeout and pixel slop constants.
   ui::GestureDetector::Config gesture_detector_config_;
 
+  // Gesture Handler to interpret the touch events.
+  ui::GestureProviderAura gesture_provider_;
+
   // The previous state entered.
   State prev_state_;
 
   // A copy of the previous event passed.
   scoped_ptr<ui::TouchEvent> prev_event_;
 
   DISALLOW_COPY_AND_ASSIGN(TouchExplorationController);
 };
 
 }  // namespace ui
 
 #endif  // UI_CHROMEOS_TOUCH_EXPLORATION_CONTROLLER_H_