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 TouchEvent;
+class GestureProviderAura;

[dmazzoni, 2014/06/23 15:50:45]

Nit: sort these (alphabetize)

+class GestureEvent;
 
 // TouchExplorationController is used in tandem with "Spoken Feedback" to
 // 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.
@@ skipping 37 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);
 
+  // The gesture provider keeps track of all the touch events after

[dmazzoni, 2014/06/23 15:50:44]

Put an extra line at the top of this comment block that says "Overridden from
GestureProviderAuraClient." This is convention we have that in any class that
inherits from one or more other classes, we always clearly identify which
functions are inheriting from which parent classes, and which ones are new. In
this case, everything is new except this one.

Here's an example of a class that inherits from two others and calls out two
overridden functions:
https://code.google.com/p/chromium/codesearch#chromium/src/ui/views/controls/...

+  // 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;
+
   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,
 
+    // We're currently making a gesture.

[dmazzoni, 2014/06/23 15:50:44]

Add a bit more detail here: explain how we enter this mode because we otherwise
would have been in touch exploration mode, but the velocity is greater than a
certain threshold, and explain when we exit this state.

+    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

[dmazzoni, 2014/06/23 15:50:44]

Nit: end with period.

+  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_