Two Finger Tap

ui/chromeos/touch_exploration_controller.cc

 // 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.
 
 #include "ui/chromeos/touch_exploration_controller.h"
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/events/event.h"
 #include "ui/events/event_processor.h"
 #include "ui/events/event_utils.h"
 #include "ui/gfx/geometry/rect.h"
 
 #define VLOG_STATE() if (VLOG_IS_ON(0)) VlogState(__func__)
 #define VLOG_EVENT(event) if (VLOG_IS_ON(0)) VlogEvent(event, __func__)
 
 namespace ui {
 
 namespace {
 
 // Delay between adjustment sounds.
 const base::TimeDelta kSoundDelay = base::TimeDelta::FromMilliseconds(150);
 
 // In ChromeOS, VKEY_LWIN is synonymous for the search key.
 const ui::KeyboardCode kChromeOSSearchKey = ui::VKEY_LWIN;
+
+// Delay to indicate that a two finger tap has occured.
+const base::TimeDelta kTwoFingerTap = base::TimeDelta::FromMilliseconds(50);
+
 }  // namespace
 
 TouchExplorationController::TouchExplorationController(
     aura::Window* root_window,
     TouchExplorationControllerDelegate* delegate)
     : root_window_(root_window),
       delegate_(delegate),
       state_(NO_FINGERS_DOWN),
       gesture_provider_(this),
       prev_state_(NO_FINGERS_DOWN),
@@ skipping 87 matching lines @@
     case GESTURE_IN_PROGRESS:
       return InGestureInProgress(touch_event, rewritten_event);
     case TOUCH_EXPLORE_SECOND_PRESS:
       return InTouchExploreSecondPress(touch_event, rewritten_event);
     case SLIDE_GESTURE:
       return InSlideGesture(touch_event, rewritten_event);
     case ONE_FINGER_PASSTHROUGH:
       return InOneFingerPassthrough(touch_event, rewritten_event);
     case WAIT_FOR_ONE_FINGER:
       return InWaitForOneFinger(touch_event, rewritten_event);
+    case TWO_FINGER_TAP:
+      return InTwoFingerTap(touch_event, rewritten_event);
   }
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::NextDispatchEvent(
     const ui::Event& last_event, scoped_ptr<ui::Event>* new_event) {
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InNoFingersDown(
     const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
-  if (type == ui::ET_TOUCH_PRESSED) {
-    initial_press_.reset(new TouchEvent(event));
-    last_unused_finger_event_.reset(new TouchEvent(event));
-    StartTapTimer();
-    gesture_provider_.OnTouchEvent(event);
-    gesture_provider_.OnTouchEventAck(false);
-    ProcessGestureEvents();
-    state_ = SINGLE_TAP_PRESSED;
-    VLOG_STATE();
-    return ui::EVENT_REWRITE_DISCARD;
+  if (type != ui::ET_TOUCH_PRESSED) {
+    NOTREACHED() << "Unexpected event type received: " << event.name();
+    return ui::EVENT_REWRITE_CONTINUE;
   }
-  NOTREACHED() << "Unexpected event type received: " << event.name();
-  return ui::EVENT_REWRITE_CONTINUE;
+  initial_press_.reset(new TouchEvent(event));
+  initial_presses_[event.touch_id()] = event.location();
+  last_unused_finger_event_.reset(new TouchEvent(event));
+  StartTapTimer();
+  gesture_provider_.OnTouchEvent(event);
+  gesture_provider_.OnTouchEventAck(false);
+  ProcessGestureEvents();
+  state_ = SINGLE_TAP_PRESSED;
+  VLOG_STATE();
+  return ui::EVENT_REWRITE_DISCARD;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InSingleTapPressed(
     const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
 
   if (type == ui::ET_TOUCH_PRESSED) {
-    // TODO (evy, lisayin) : add support for multifinger swipes.
+    initial_presses_[event.touch_id()] = event.location();
+    if ((event.time_stamp() - initial_press_->time_stamp()) < kTwoFingerTap) {
+      state_ = TWO_FINGER_TAP;
+      VLOG_STATE();
+      return EVENT_REWRITE_DISCARD;
+    }
     // For now, we wait for there to be only one finger down again.
     state_ = WAIT_FOR_ONE_FINGER;
     return EVENT_REWRITE_DISCARD;
   } else if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
     if (current_touch_ids_.size() == 0 &&
         event.touch_id() == initial_press_->touch_id()) {
       state_ = SINGLE_TAP_RELEASED;
       VLOG_STATE();
     } else if (current_touch_ids_.size() == 0) {
       ResetToNoFingersDown();
@@ skipping 360 matching lines @@
     if (current_touch_ids_.size() == 0) {
       ResetToNoFingersDown();
     }
     return ui::EVENT_REWRITE_DISCARD;
   }
 
   ProcessGestureEvents();
   return ui::EVENT_REWRITE_DISCARD;
 }
 
+ui::EventRewriteStatus TouchExplorationController::InTwoFingerTap(
+    const ui::TouchEvent& event,
+    scoped_ptr<ui::Event>* rewritten_event) {
+  ui::EventType type = event.type();
+  if (type == ui::ET_TOUCH_PRESSED) {
+    // TODO(evy): Process three finger gestures here.
+    state_ = WAIT_FOR_ONE_FINGER;
+    VLOG_STATE();
+    return ui::EVENT_REWRITE_DISCARD;
+  }
+
+  if (type == ui::ET_TOUCH_MOVED) {
+    // Determine if it was a swipe.
+    gfx::Point original_location = initial_presses_[event.touch_id()];
+    float distance = (event.location() - original_location).Length();
+    // If the user moves too far from the original position, consider the
+    // movement a swipe.

[aboxhall, 2014/08/07 22:45:19]

Does this logic need extra testing?

[lisayin, 2014/08/08 02:12:24]

Done.

+    // TODO(evy, lisayin): Add multifinger swipe processing.
+    if (distance <= gesture_detector_config_.touch_slop) {
+      state_ = WAIT_FOR_ONE_FINGER;
+    }
+    return ui::EVENT_REWRITE_DISCARD;
+  }
+
+  if (current_touch_ids_.size() != 0)
+    return ui::EVENT_REWRITE_DISCARD;
+
+  if (type == ui::ET_TOUCH_RELEASED) {
+    ui::KeyEvent control_down(
+        ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN);
+    ui::KeyEvent control_up(ui::ET_KEY_RELEASED, ui::VKEY_CONTROL, ui::EF_NONE);
+
+    DispatchEvent(&control_down);
+    DispatchEvent(&control_up);
+
+    ResetToNoFingersDown();
+    return ui::EVENT_REWRITE_DISCARD;
+  }
+  return ui::EVENT_REWRITE_DISCARD;
+}
+
 base::TimeDelta TouchExplorationController::Now() {
   if (tick_clock_) {
     // This is the same as what EventTimeForNow() does, but here we do it
     // with a clock that can be replaced with a simulated clock for tests.
     return base::TimeDelta::FromInternalValue(
         tick_clock_->NowTicks().ToInternalValue());
   }
   return ui::EventTimeForNow();
 }
 
@@ skipping 26 matching lines @@
       DispatchEvent(passthrough_press.get());
       return;
     }
     case SINGLE_TAP_PRESSED:
     case GESTURE_IN_PROGRESS:
       // Discard any pending gestures.
       delete gesture_provider_.GetAndResetPendingGestures();
       state_ = TOUCH_EXPLORATION;
       VLOG_STATE();
       break;
+    case TWO_FINGER_TAP:
+      state_ = WAIT_FOR_ONE_FINGER;
+      VLOG_STATE();
+      break;
     default:
       return;
   }
   EnterTouchToMouseMode();
   scoped_ptr<ui::Event> mouse_move =
       CreateMouseMoveEvent(initial_press_->location(), initial_press_->flags());
   DispatchEvent(mouse_move.get());
   last_touch_exploration_.reset(new TouchEvent(*initial_press_));
 }
 
@@ skipping 185 matching lines @@
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(root_window_);
   if (cursor_client && !cursor_client->IsMouseEventsEnabled())
     cursor_client->EnableMouseEvents();
   if (cursor_client && cursor_client->IsCursorVisible())
     cursor_client->HideCursor();
 }
 
 void TouchExplorationController::ResetToNoFingersDown() {
   ProcessGestureEvents();
+  initial_presses_.clear();
   if (sound_timer_.IsRunning())
     sound_timer_.Stop();
   state_ = NO_FINGERS_DOWN;
   VLOG_STATE();
   if (tap_timer_.IsRunning())
     tap_timer_.Stop();
 }
 
 void TouchExplorationController::VlogState(const char* function_name) {
   if (!VLOG_on_)
@@ skipping 55 matching lines @@
     case GESTURE_IN_PROGRESS:
       return "GESTURE_IN_PROGRESS";
     case TOUCH_EXPLORE_SECOND_PRESS:
       return "TOUCH_EXPLORE_SECOND_PRESS";
     case SLIDE_GESTURE:
       return "SLIDE_GESTURE";
     case ONE_FINGER_PASSTHROUGH:
       return "ONE_FINGER_PASSTHROUGH";
     case WAIT_FOR_ONE_FINGER:
       return "WAIT_FOR_ONE_FINGER";
+    case TWO_FINGER_TAP:
+      return "TWO_FINGER_TAP";
   }
   return "Not a state";
 }
 
 }  // namespace ui