Two Finger Tap

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 22 matching lines @@
  public:
   virtual ~TouchExplorationControllerDelegate() {}
 
   // This function should be called whenever the delegate wants to play a sound
   // when the volume adjusts.
   virtual void PlayVolumeAdjustSound() = 0;
 
   // Takes an int from 0.0 to 100.0 that indicates the percent the volume
   // should be set to.
   virtual void SetOutputLevel(int volume) = 0;
+
+  // Silences spoken feedback.
+  virtual void SilenceSpokenFeedback() = 0;
 };
 
 // TouchExplorationController is used in tandem with "Spoken Feedback" to
 // make the touch UI accessible. Gestures performed in the middle of the screen
 // are mapped to accessiblity key shortcuts while gestures performed on the edge
 // 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
 // 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.
+// 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. If
+// the user taps the screen with two fingers, the user can silence spoken
+// feedback if it is playing.
 //
 // ** Long version **
 //
 // Here are the details of the implementation:
 //
 // When the first touch is pressed, a 300 ms grace period timer starts.
 //
 // If the user keeps their finger down for more than 300 ms and doesn't
 // perform a supported accessibility gesture in that time (e.g. swipe right),
 // they enter touch exploration mode, and all movements are translated into
@@ skipping 33 matching lines @@
 // location, and every following event is offset by the same amount.
 //
 // If any other fingers are added or removed, they are ignored. Once the
 // passthrough finger is released, passthrough stops and the user is reset
 // to no fingers down state.
 //
 // If the user enters touch exploration mode, they can click without lifting
 // their touch exploration finger by tapping anywhere else on the screen with
 // a second finger, while the touch exploration finger is still pressed.
 //
+// Once touch exploration mode has been activated, it remains in that mode until
+// all fingers have been released.
+//
 // If the user places a finger on the edge of the screen and moves their finger
 // past slop, a slide gesture is performed. The user can then slide one finger
 // along an edge of the screen and continuously control a setting. Once the user
 // enters this state, the boundaries that define an edge expand so that the user
 // can now adjust the setting within a slightly bigger width along the screen.
 // If the user exits this area without lifting their finger, they will not be
 // able to perform any actions, however if they keep their finger down and
 // return to the "hot edge," then they can still adjust the setting. In order to
 // perform other touch accessibility movements, the user must lift their finger.
 // If additional fingers are added while in this state, the user will transition
 // to passthrough.
 //
 // Currently, only the right edge is mapped to control the volume. Volume
 // control along the edge of the screen is directly proportional to where the
 // user's finger is located on the screen. The top right corner of the screen
 // automatically sets the volume to 100% and the bottome right corner of the
 // screen automatically sets the volume to 0% once the user has moved past slop.
 //
-// Once touch exploration mode has been activated,
-// it remains in that mode until all fingers have been released.
+// If the user taps the screen with two fingers and lifts both fingers before
+// the grace period has passed, spoken feedback is silenced.
 //
 // 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::GestureProviderAuraClient {
  public:
   explicit TouchExplorationController(
       aura::Window* root_window,
       ui::TouchExplorationControllerDelegate* delegate);
@@ skipping 27 matching lines @@
   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(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus InSlideGesture(
       const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event);
+  ui::EventRewriteStatus InTwoFingerTap(
+      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();
@@ skipping 111 matching lines @@
     // passthrough, touch exploration, and gestures, they must release
     // all fingers except 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,
 
     // 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,
+
+    // If the user taps the screen with two fingers and releases both fingers
+    // before the grace period has passed, spoken feedback will be silenced.
+    TWO_FINGER_TAP,
   };
 
   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,
   };
@@ skipping 21 matching lines @@
 
   // Map of touch ids to their last known location.
   std::map<int, gfx::PointF> touch_locations_;
 
   // The current state.
   State state_;
 
   // A copy of the event from the initial touch press.
   scoped_ptr<ui::TouchEvent> initial_press_;
 
+  // Map of touch ids to where its initial press occured relative to the screen.

[James Cook, 2014/08/08 20:07:23]

occured -> occurred

[lisayin, 2014/08/08 20:14:05]

Done.

+  std::map<int, gfx::Point> initial_presses_;
+
   // In one finger passthrough, the touch is displaced relative to the
   // last touch exploration location.
   gfx::Vector2d passthrough_offset_;
 
   // 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,
@@ skipping 25 matching lines @@
   // 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_;
 
   DISALLOW_COPY_AND_ASSIGN(TouchExplorationController);
 };
 
 }  // namespace ui
 
 #endif  // UI_CHROMEOS_TOUCH_EXPLORATION_CONTROLLER_H_