Added multi-finger gestures to touch_exploration_controller

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/time/tick_clock.h"
 #include "base/timer/timer.h"
 #include "base/values.h"
@@ skipping 37 matching lines @@
 // of the screen can change settings.
 //
 // ** 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 single tap while the user
 // is in touch exploration or a double-tap simulates a click, and gestures
 // can be used to send high-level accessibility commands. For example, a swipe
 // right would correspond to the keyboard short cut shift+search+right.
-// 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
-// down with two fingers, the running app will see a one-finger swipe. Slide
+// Swipes with up to four fingers are also mapped to commands. Slide
 // gestures performed on the edge of the screen can change settings
 // continuously. For example, sliding a finger along the right side of the
 // screen will change the volume.
 // When a user double taps and holds with one finger, the finger is passed
 // through as if accessibility was turned off.
 //
 // ** Long version **
 //
 // Here are the details of the implementation:
 //
@@ skipping 11 matching lines @@
 // If the user taps and releases their finger, after 300 ms from the initial
 // touch, a single mouse move is fired.
 //
 // While in touch exploration mode, the user can perform a single tap
 // if the user releases their finger and taps before 300 ms passes.
 // This will result in a click on the last successful touch exploration
 // location. This allows the user to perform a single tap
 // anywhere to activate it.
 //
 // The user can perform swipe gestures in one of the four cardinal directions
-// which will be interpreted and used to control the UI. The gesture will only
-// be registered if the finger moves outside the slop and completed within the
-// grace period. If additional fingers are added during the grace period, the
-// state changes to wait for those fingers to be released, and then goes to
-// touch exploration mode. If the gesture fails to be completed within the
-// grace period, the state changes to touch exploration mode. Once the state has
-// changed, any gestures made during the grace period are discarded.
+// which will be interpreted and used to control the UI. One finger gestures

[lisayin, 2014/08/06 22:43:29]

Should this be multifinger gestures?

[evy, 2014/08/06 22:59:14]

Done.

+// will only be registered if the fingers move outside the slop, and all fingers
+// will only be registered if they are completed within the grace period. If a
+// single finger gesture fails to be completed within the grace period, the
+// state changes to touch exploration mode. If a multi finger gesture fails to
+// be completed within the grace period, the user must lift all fingers before
+// completing any more actions.
 //
 // If the user double-taps, the second tap is passed through, allowing the
 // user to click - however, the double-tap location is changed to the location
 // of the last successful touch exploration - that allows the user to explore
 // anywhere on the screen, hear its description, then double-tap anywhere
 // to activate it.
 //
 // If the user double taps and holds, any event from that finger is passed
 // through. These events are passed through with an offset such that the first
 // touch is offset to be at the location of the last touch exploration
@@ skipping 55 matching lines @@
   ui::EventRewriteStatus InSingleTapPressed(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InSingleTapOrTouchExploreReleased(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InDoubleTapPending(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InTouchReleasePending(
       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 InTwoToOneFinger(
-      const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InOneFingerPassthrough(
       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 InTouchExploreSecondPress(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
-  ui::EventRewriteStatus InWaitForOneFinger(
+  ui::EventRewriteStatus InWaitForNoFingers(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InSlideGesture(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
 
   // Returns the current time of the tick clock.
   base::TimeDelta Now();
 
   // 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 StartTapTimer();
   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.
   virtual void OnGestureEvent(ui::GestureEvent* gesture) OVERRIDE;
 
   // Process the gesture events that have been created.
   void ProcessGestureEvents();
 
   void OnSwipeEvent(ui::GestureEvent* swipe_gesture);
-
   void SideSlideControl(ui::GestureEvent* gesture);
 
-  // Dispatches the keyboard short cut Shift+Search+<arrow key>
+  // Dispatches the keyboard short cut Shift+Search+<key>
   // outside the event rewritting flow.
-  void DispatchShiftSearchKeyEvent(const ui::KeyboardCode direction);
+  void DispatchShiftSearchKeyEvent(const ui::KeyboardCode third_key);
+
+  // Dispatches a single key with the given flags.
+  void DispatchKeyWithFlags(const ui::KeyboardCode key, int flags);
 
   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();
 
@@ skipping 23 matching lines @@
 
     // The user pressed and released a single finger - a tap - but we have
     // to wait until the end of the grace period to allow the user to tap the
     // second time. If the second tap doesn't occurs within the grace period,
     // we dispatch a mouse move at the location of the first tap.
     SINGLE_TAP_RELEASED,
 
     // The user was in touch explore mode and released the finger.
     // If another touch press occurs within the grace period, a single
     // tap click occurs. This state differs from SINGLE_TAP_RELEASED
-    // In that if a second tap doesn't occur within the grace period,
+    // in that if a second tap doesn't occur within the grace period,
     // there is no mouse move dispatched.
     TOUCH_EXPLORE_RELEASED,
 
     // The user tapped once, and before the grace period expired, pressed
     // one finger down to begin a double-tap, but has not released it yet.
     // This could become passthrough, so no touch press is dispatched yet.
     DOUBLE_TAP_PENDING,
 
     // The user was doing touch exploration, started split tap, but lifted the
     // touch exploration finger. Once they remove all fingers, a touch release
@@ skipping 26 matching lines @@
 
     // After the user double taps and holds with a single finger, all events
     // for that finger are passed through, displaced by an offset. Adding
     // extra fingers has no effect. This state is left when the user removes
     // all fingers.
     ONE_FINGER_PASSTHROUGH,
 
     // If the user added another finger in SINGLE_TAP_PRESSED, or if the user
     // has multiple fingers fingers down in any other state between
     // passthrough, touch exploration, and gestures, they must release
-    // all fingers except before completing any more actions. This state is
+    // all fingers before completing any more actions. This state is
     // generally useful for developing new features, because it creates a
     // simple way to handle a dead end in user flow.
-    WAIT_FOR_ONE_FINGER,
+    WAIT_FOR_NO_FINGERS,
 
     // If the user is within the given bounds from an edge of the screen, not
     // including corners, then the resulting movements will be interpreted as
     // slide gestures.
     SLIDE_GESTURE,
   };
 
   enum ScreenLocation {
     // Hot "edges" of the screen are each represented by a respective bit.
     NO_EDGE = 0,
     RIGHT_EDGE = 1 << 0,
     TOP_EDGE = 1 << 1,
     LEFT_EDGE = 1 << 2,
     BOTTOM_EDGE = 1 << 3,
   };
 
   // Given a point, if it is within the given bounds of an edge, returns the
   // edge. If it is within the given bounds of two edges, returns an int with
   // both bits that represent the respective edges turned on. Otherwise returns
   // SCREEN_CENTER.
   int FindEdgesWithinBounds(gfx::Point point, float bounds);
 
   void VlogState(const char* function_name);
 
   void VlogEvent(const ui::TouchEvent& event, const char* function_name);
 
   // Gets enum name from integer value.
   const char* EnumStateToString(State state);
 
+  // Maps each single/multi finger swipe to the function that dispatches
+  // the corresponding key events.
+  void InitializeSwipeGestureMaps();
+
   aura::Window* root_window_;
 
   // Handles volume control. Not owned.
   ui::TouchExplorationControllerDelegate* delegate_;
 
   // A set of touch ids for fingers currently touching the screen.
   std::vector<int> current_touch_ids_;
 
   // Map of touch ids to their last known location.
   std::map<int, gfx::PointF> touch_locations_;
@@ skipping 10 matching lines @@
 
   // Stores the most recent event from a finger that is currently not
   // sending events through, but might in the future (e.g. before a finger
   // enters double-tap-hold passthrough, we need to update its location.)
   scoped_ptr<ui::TouchEvent> last_unused_finger_event_;
 
   // The last synthesized mouse move event. When the user double-taps,
   // we send the passed-through tap to the location of this event.
   scoped_ptr<ui::TouchEvent> last_touch_exploration_;
 
-  // A timer to fire the mouse move event after the double-tap delay.
+  // A timer that fires after the double-tap delay.
   base::OneShotTimer<TouchExplorationController> tap_timer_;
 
   // A timer to fire an indicating sound when sliding to change volume.
   base::RepeatingTimer<TouchExplorationController> sound_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_;
+  scoped_ptr<ui::GestureProviderAura> gesture_provider_;
 
   // The previous state entered.
   State prev_state_;
 
   // A copy of the previous event passed.
   scoped_ptr<ui::TouchEvent> prev_event_;
 
   // This toggles whether VLOGS are turned on or not.
   bool VLOG_on_;
 
   // When touch_exploration_controller gets time relative to real time during
   // testing, this clock is set to the simulated clock and used.
   base::TickClock* tick_clock_;
 
+  // Maps swipes with the resulting functions that dispatch key events.
+  std::map<int, base::Closure> left_swipe_gestures_;
+  std::map<int, base::Closure> right_swipe_gestures_;
+  std::map<int, base::Closure> up_swipe_gestures_;
+  std::map<int, base::Closure> down_swipe_gestures_;
+
   DISALLOW_COPY_AND_ASSIGN(TouchExplorationController);
 };
 
 }  // namespace ui
 
 #endif  // UI_CHROMEOS_TOUCH_EXPLORATION_CONTROLLER_H_