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;
 }
@@ skipping 14 matching lines @@
   }
   NOTREACHED() << "Unexpected event type received: " << event.name();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 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) {
+    if ((event.time_stamp() - initial_press_->time_stamp()) < kTwoFingerTap) {
+      state_ = TWO_FINGER_TAP;
+      VLOG_STATE();
+      return EVENT_REWRITE_DISCARD;
+    }
     // TODO (evy, lisayin) : add support for multifinger swipes.
     // 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) {
@@ skipping 361 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) {
+    state_ = WAIT_FOR_ONE_FINGER;

[dmazzoni, 2014/07/31 20:44:43]

Do we really want to wait for one finger?

I'd prefer we avoid situations were a user could do some action for a long time,
then release fingers and suddenly end up entering touch exploration. I think we
should either enter touch exploration mode early, or never.

[lisayin, 2014/07/31 21:43:27]

I agree, but Evy is writing WAIT_FOR_NO_FINGERS_DOWN so I don't want to make
another method that conflicts with that one.

+    VLOG_STATE();
+    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 260 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