Swipe Gestures for Accessibility

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"
 
 #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 {
+// In ChromeOS, VKEY_LWIN is synonymous for the search key.
+const ui::KeyboardCode kChromeOSSearchKey = ui::VKEY_LWIN;
+}  // namespace
+
 TouchExplorationController::TouchExplorationController(
     aura::Window* root_window)
     : root_window_(root_window),
       state_(NO_FINGERS_DOWN),
       event_handler_for_testing_(NULL),
+      gesture_provider_(this),
       prev_state_(NO_FINGERS_DOWN) {
   CHECK(root_window);
   root_window->GetHost()->GetEventSource()->AddEventRewriter(this);
 }
 
 
 TouchExplorationController::~TouchExplorationController() {
   root_window_->GetHost()->GetEventSource()->RemoveEventRewriter(this);
 }
 
 void TouchExplorationController::CallTapTimerNowForTesting() {
   DCHECK(tap_timer_.IsRunning());
   tap_timer_.Stop();
   OnTapTimerFired();
 }
 
 void TouchExplorationController::SetEventHandlerForTesting(
     ui::EventHandler* event_handler_for_testing) {
   event_handler_for_testing_ = event_handler_for_testing;
 }
 
 bool TouchExplorationController::IsInNoFingersDownStateForTesting() const {
   return state_ == NO_FINGERS_DOWN;
 }
 
+bool TouchExplorationController::IsInGestureInProgressStateForTesting() const {

[aboxhall, 2014/07/02 16:45:57]

suggestion: should we just have a GetStateForTesting() method instead?

[lisayin, 2014/07/02 17:09:50]

The state enum is private so I don't think that we would be able to access it to
be able to compare states in the testing file.

[aboxhall, 2014/07/02 18:00:13]

Ahh, that makes sense, thanks.

+  return state_ == GESTURE_IN_PROGRESS;
+}
+
 ui::EventRewriteStatus TouchExplorationController::RewriteEvent(
     const ui::Event& event,
     scoped_ptr<ui::Event>* rewritten_event) {
   if (!event.IsTouchEvent()) {
     if (event.IsKeyEvent()) {
       const ui::KeyEvent& key_event = static_cast<const ui::KeyEvent&>(event);
       VLOG(0) << "\nKeyboard event: " << key_event.name() << "\n"
               << " Key code: " << key_event.key_code()
               << ", Flags: " << key_event.flags()
               << ", Is char: " << key_event.is_char();
     }
-    if(event.IsGestureEvent()){
-      VLOG(0) << "\n Gesture event " << event.name();
-    }
     return ui::EVENT_REWRITE_CONTINUE;
   }
   const ui::TouchEvent& touch_event = static_cast<const ui::TouchEvent&>(event);
 
   // If the tap timer should have fired by now but hasn't, run it now and
   // stop the timer. This is important so that behavior is consistent with
   // the timestamps of the events, and not dependent on the granularity of
   // the timer.
   if (tap_timer_.IsRunning() &&
       touch_event.time_stamp() - initial_press_->time_stamp() >
@@ skipping 41 matching lines @@
       return InNoFingersDown(touch_event, rewritten_event);
     case SINGLE_TAP_PRESSED:
       return InSingleTapPressed(touch_event, rewritten_event);
     case SINGLE_TAP_RELEASED:
     case TOUCH_EXPLORE_RELEASED:
       return InSingleTapOrTouchExploreReleased(touch_event, rewritten_event);
     case DOUBLE_TAP_PRESSED:
       return InDoubleTapPressed(touch_event, rewritten_event);
     case TOUCH_EXPLORATION:
       return InTouchExploration(touch_event, rewritten_event);
+    case GESTURE_IN_PROGRESS:
+      return InGestureInProgress(touch_event, rewritten_event);
     case TOUCH_EXPLORE_SECOND_PRESS:
       return InTouchExploreSecondPress(touch_event, rewritten_event);
     case TWO_TO_ONE_FINGER:
       return InTwoToOneFinger(touch_event, rewritten_event);
     case PASSTHROUGH:
       return InPassthrough(touch_event, rewritten_event);
     case WAIT_FOR_RELEASE:
       return InWaitForRelease(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));
     tap_timer_.Start(FROM_HERE,
                      gesture_detector_config_.double_tap_timeout,
                      this,
                      &TouchExplorationController::OnTapTimerFired);
+    gesture_provider_.OnTouchEvent(event);
+    gesture_provider_.OnTouchEventAck(false);
     state_ = SINGLE_TAP_PRESSED;
     VLOG_STATE();
     return ui::EVENT_REWRITE_DISCARD;
   }
   NOTREACHED() << "Unexpected event type received.";
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InSingleTapPressed(
     const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event) {
@@ skipping 10 matching lines @@
                                               event.touch_id(),
                                               event.time_stamp()));
     (*rewritten_event)->set_flags(event.flags());
     return EVENT_REWRITE_REWRITTEN;
   } else if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
     DCHECK_EQ(0U, current_touch_ids_.size());
     state_ = SINGLE_TAP_RELEASED;
     VLOG_STATE();
     return EVENT_REWRITE_DISCARD;
   } else if (type == ui::ET_TOUCH_MOVED) {
-    // If the user moves far enough from the initial touch location (outside
-    // the "slop" region, jump to the touch exploration mode early.
-    // TODO(evy, lisayin): Add gesture recognition here instead -
-    // we should probably jump to gesture mode here if the velocity is
-    // high enough, and touch exploration if the velocity is lower.
-    float delta = (event.location() - initial_press_->location()).Length();
-    if (delta > gesture_detector_config_.touch_slop) {
-      EnterTouchToMouseMode();
-      state_ = TOUCH_EXPLORATION;
+    float delta_time =
+        (event.time_stamp() - initial_press_->time_stamp()).InSecondsF();
+    float delta_distance =

[aboxhall, 2014/07/02 16:45:57]

nit: I think this should just be 'distance'

[lisayin, 2014/07/02 17:19:43]

Done.

+        (event.location() - initial_press_->location()).Length();
+    float velocity = delta_distance / delta_time;
+    VLOG(0) << "\n Delta time: " << delta_time
+            << "\n Delta distance: " << delta_distance
+            << "\n Velocity of click: " << velocity
+            << "\n Minimum swipe velocity: "
+            << gesture_detector_config_.minimum_swipe_velocity;
+    if (delta_distance <= gesture_detector_config_.touch_slop)

[aboxhall, 2014/07/02 16:45:57]

Presumably we don't need to compute delta_time and velocity before we early-out
here, since we're not using them in this check.

Also, a comment explaining this early out would probably be helpful.

[lisayin, 2014/07/02 17:19:43]

Done.

+      return EVENT_REWRITE_DISCARD;
+
+    // If the user moves fast enough and far enough

[aboxhall, 2014/07/02 16:45:57]

Re-flow this comment (I think tab should do it)

Also, does "far enough from the initial touch location" simply mean outside the
slop region? Since you're early outing above, that should be self explanatory if
you add a comment to the early out, so you probably don't need to mention it
here.

[lisayin, 2014/07/02 17:19:43]

Done.

+    // from the initial touch location, start gesture detection.
+    // Otherwise, if the user moves far enough from the initial touch location
+    // outside the "slop" region, jump to the touch exploration mode early.
+    if (velocity > gesture_detector_config_.minimum_swipe_velocity) {
+      state_ = GESTURE_IN_PROGRESS;
       VLOG_STATE();
-      return InTouchExploration(event, rewritten_event);
+      return InGestureInProgress(event, rewritten_event);
     }
-    return EVENT_REWRITE_DISCARD;
+    EnterTouchToMouseMode();
+    state_ = TOUCH_EXPLORATION;
+    VLOG_STATE();
+    return InTouchExploration(event, rewritten_event);
   }
   NOTREACHED() << "Unexpected event type received.";
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus
 TouchExplorationController::InSingleTapOrTouchExploreReleased(
     const ui::TouchEvent& event,
     scoped_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
+  // If there is more than one finger down, then discard to wait until only one
+  // finger is or no fingers are down (should be replaced with wait_state).
+  if (current_touch_ids_.size() > 1) {
+    state_ = WAIT_FOR_RELEASE;
+    return ui::EVENT_REWRITE_DISCARD;
+  }
+  // If there is no touch exploration yet, discard.
+  if (last_touch_exploration_ == NULL || type == ui::ET_TOUCH_RELEASED) {
+    if (current_touch_ids_.size() == 0) {
+      ResetToNoFingersDown();
+    }
+    return ui::EVENT_REWRITE_DISCARD;
+  }
+
   if (type == ui::ET_TOUCH_PRESSED) {
     // This is the second tap in a double-tap (or double tap-hold).
     // Rewrite at location of last touch exploration.
-    // If there is no touch exploration yet, discard instead.
-    if (!last_touch_exploration_) {
-      return ui::EVENT_REWRITE_DISCARD;
-    }
     rewritten_event->reset(
         new ui::TouchEvent(ui::ET_TOUCH_PRESSED,
                            last_touch_exploration_->location(),
                            event.touch_id(),
                            event.time_stamp()));
     (*rewritten_event)->set_flags(event.flags());
     state_ = DOUBLE_TAP_PRESSED;
     VLOG_STATE();
     return ui::EVENT_REWRITE_REWRITTEN;
-  } else if (type == ui::ET_TOUCH_RELEASED && !last_touch_exploration_) {
-    // If the previous press was discarded, we need to also handle its
-    // release.
-    if (current_touch_ids_.size() == 0) {
-      ResetToNoFingersDown();
-    }
-    return ui::EVENT_REWRITE_DISCARD;
   }
   NOTREACHED() << "Unexpected event type received.";
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InDoubleTapPressed(
     const ui::TouchEvent& event, scoped_ptr<ui::Event>* rewritten_event) {
   const ui::EventType type = event.type();
   if (type == ui::ET_TOUCH_PRESSED) {
     return ui::EVENT_REWRITE_DISCARD;
   } else if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
     if (current_touch_ids_.size() != 0)
       return EVENT_REWRITE_DISCARD;
 
     // Rewrite release at location of last touch exploration with the same
-    // id as the prevoius press.
+    // id as the previous press.
     rewritten_event->reset(
         new ui::TouchEvent(ui::ET_TOUCH_RELEASED,
                            last_touch_exploration_->location(),
                            initial_press_->touch_id(),
                            event.time_stamp()));
     (*rewritten_event)->set_flags(event.flags());
     ResetToNoFingersDown();
     return ui::EVENT_REWRITE_REWRITTEN;
   } else if (type == ui::ET_TOUCH_MOVED) {
     return ui::EVENT_REWRITE_DISCARD;
@@ skipping 32 matching lines @@
     NOTREACHED() << "Unexpected event type received.";
     return ui::EVENT_REWRITE_CONTINUE;
   }
 
   // Rewrite as a mouse-move event.
   *rewritten_event = CreateMouseMoveEvent(event.location(), event.flags());
   last_touch_exploration_.reset(new TouchEvent(event));
   return ui::EVENT_REWRITE_REWRITTEN;
 }
 
+ui::EventRewriteStatus TouchExplorationController::InGestureInProgress(
+    const ui::TouchEvent& event,
+    scoped_ptr<ui::Event>* rewritten_event) {
+  ui::EventType type = event.type();
+  if (type == ui::ET_TOUCH_PRESSED ||
+      event.touch_id() != initial_press_->touch_id()) {
+    // Should go to passthrough mode.
+    if (tap_timer_.IsRunning())
+      tap_timer_.Stop();
+    // Discard any pending gestures.
+    scoped_ptr<ScopedVector<ui::GestureEvent> > gestures(

[aboxhall, 2014/07/02 16:45:58]

Since you're not using |gestures|, you can use ignore_result() here:
https://code.google.com/p/chromium/codesearch#chromium/src/base/macros.h&q=ig...

[lisayin, 2014/07/02 17:09:50]

Will I still need to cast the return from GetAndResetPendingGestures to a scoped
pointer?

[aboxhall, 2014/07/02 18:00:13]

I see you figured this out :)

+        gesture_provider_.GetAndResetPendingGestures());
+    state_ = TWO_TO_ONE_FINGER;
+    last_two_to_one_.reset(new TouchEvent(event));
+    rewritten_event->reset(new ui::TouchEvent(ui::ET_TOUCH_PRESSED,
+                                              event.location(),
+                                              event.touch_id(),
+                                              event.time_stamp()));
+    (*rewritten_event)->set_flags(event.flags());
+    return EVENT_REWRITE_REWRITTEN;
+  }
+  /*
+  if (last_touch_exploration_ == NULL) {

[aboxhall, 2014/07/02 16:45:57]

Should this be uncommented or removed?

[lisayin, 2014/07/02 17:19:44]

Done.

+    last_touch_exploration_.reset(initial_press_.get());
+    }*/
+  if (type == ui::ET_TOUCH_MOVED) {
+    gesture_provider_.OnTouchEvent(event);
+    gesture_provider_.OnTouchEventAck(false);
+  }
+  if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
+    gesture_provider_.OnTouchEvent(event);
+    gesture_provider_.OnTouchEventAck(false);
+    if (current_touch_ids_.size() == 0)
+      ResetToNoFingersDown();
+  }
+  return ui::EVENT_REWRITE_DISCARD;
+}
 
 ui::EventRewriteStatus TouchExplorationController::InTwoToOneFinger(
     const ui::TouchEvent& event,
     scoped_ptr<ui::Event>* rewritten_event) {
   // The user should only ever be in TWO_TO_ONE_FINGER with two fingers down.
   // If the user added or removed a finger, the state is changed.
   ui::EventType type = event.type();
   if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
     DCHECK(current_touch_ids_.size() == 1);
     // Stop passing through the second finger and go to the wait state.
@@ skipping 98 matching lines @@
     if (current_touch_ids_.size() != 1)
       return EVENT_REWRITE_DISCARD;
 
     // Rewrite at location of last touch exploration.
     rewritten_event->reset(
         new ui::TouchEvent(ui::ET_TOUCH_RELEASED,
                            last_touch_exploration_->location(),
                            initial_press_->touch_id(),
                            event.time_stamp()));
     (*rewritten_event)->set_flags(event.flags());
+    EnterTouchToMouseMode();
     state_ = TOUCH_EXPLORATION;
     VLOG_STATE();
     return ui::EVENT_REWRITE_REWRITTEN;
   }
   NOTREACHED() << "Unexpected event type received.";
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus TouchExplorationController::InWaitForRelease(
     const ui::TouchEvent& event,
     scoped_ptr<ui::Event>* rewritten_event) {
   ui::EventType type = event.type();
   if (!(type == ui::ET_TOUCH_PRESSED || type == ui::ET_TOUCH_MOVED ||
         type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED)) {
     NOTREACHED() << "Unexpected event type received.";
     return ui::EVENT_REWRITE_CONTINUE;
   }
   if (current_touch_ids_.size() == 0) {
     state_ = NO_FINGERS_DOWN;
+    VLOG_STATE();
     ResetToNoFingersDown();
   }
   return EVENT_REWRITE_DISCARD;
 }
 
 void TouchExplorationController::OnTapTimerFired() {
   switch (state_) {
     case SINGLE_TAP_RELEASED:
       ResetToNoFingersDown();
       break;
     case TOUCH_EXPLORE_RELEASED:
       ResetToNoFingersDown();
       last_touch_exploration_.reset(new TouchEvent(*initial_press_));
       return;
     case SINGLE_TAP_PRESSED:
+    case GESTURE_IN_PROGRESS: {
+      // Discard any pending gestures.
+      scoped_ptr<ScopedVector<ui::GestureEvent> > gestures(

[aboxhall, 2014/07/02 16:45:57]

Similarly, you can use ignore_result() here.

[lisayin, 2014/07/02 17:19:43]

Done.

+          gesture_provider_.GetAndResetPendingGestures());
       EnterTouchToMouseMode();
       state_ = TOUCH_EXPLORATION;
       VLOG_STATE();
-      break;
+    } break;
     default:
       return;
   }
-
-  scoped_ptr<ui::Event> mouse_move = CreateMouseMoveEvent(
-      initial_press_->location(), initial_press_->flags());
+  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_));
-}
+ }
 
 void TouchExplorationController::DispatchEvent(ui::Event* event) {
   if (event_handler_for_testing_) {
     event_handler_for_testing_->OnEvent(event);
     return;
   }
   ui::EventDispatchDetails result ALLOW_UNUSED =
       root_window_->GetHost()->dispatcher()->OnEventFromSource(event);
 }
 
+void TouchExplorationController::OnGestureEvent(ui::GestureEvent* gesture) {
+  if (tap_timer_.IsRunning())
+    tap_timer_.Stop();
+
+  CHECK(gesture->IsGestureEvent());
+  VLOG(0) << " \n Gesture Triggered: " << gesture->name();
+
+  if (gesture->type() == ui::ET_GESTURE_SWIPE) {
+    OnSwipeEvent(gesture);
+    return;
+  }
+  // If the event processed was not a swipe gesture, then determine the next
+  // state by the number of fingers currently down.
+  if (current_touch_ids_.size() == 0) {
+    ResetToNoFingersDown();
+  } else if (current_touch_ids_.size() == 1) {
+    EnterTouchToMouseMode();
+    state_ = TOUCH_EXPLORATION;
+  }
+}
+
+void TouchExplorationController::OnSwipeEvent(ui::GestureEvent* swipe_gesture) {
+  // A swipe gesture contains details for the direction in which the swipe
+  // occurred.
+  GestureEventDetails event_details = swipe_gesture->details();
+  if (event_details.swipe_left()) {
+    DispatchShiftSearchKeyEvent(ui::VKEY_LEFT);
+    return;
+  } else if (event_details.swipe_right()) {
+    DispatchShiftSearchKeyEvent(ui::VKEY_RIGHT);
+    return;
+  } else if (event_details.swipe_up()) {
+    DispatchShiftSearchKeyEvent(ui::VKEY_UP);
+    return;
+  } else if (event_details.swipe_down()) {
+    DispatchShiftSearchKeyEvent(ui::VKEY_DOWN);
+    return;
+  }
+}
+
+void TouchExplorationController::DispatchShiftSearchKeyEvent(
+    const ui::KeyboardCode direction) {
+  // In order to activate the shortcut shift+search+<arrow key>
+  // three KeyPressed events must be dispatched in succession along
+  // with three KeyReleased events.
+  DispatchEvent(new ui::KeyEvent(
+      ui::ET_KEY_PRESSED, ui::VKEY_SHIFT, ui::EF_SHIFT_DOWN, false));
+  DispatchEvent(new ui::KeyEvent(
+      ui::ET_KEY_PRESSED, kChromeOSSearchKey, ui::EF_SHIFT_DOWN, false));
+  DispatchEvent(new ui::KeyEvent(
+      ui::ET_KEY_PRESSED, direction, ui::EF_SHIFT_DOWN, false));
+
+  DispatchEvent(new ui::KeyEvent(
+      ui::ET_KEY_RELEASED, direction, ui::EF_SHIFT_DOWN, false));
+  DispatchEvent(new ui::KeyEvent(
+      ui::ET_KEY_RELEASED, kChromeOSSearchKey, ui::EF_SHIFT_DOWN, false));
+  DispatchEvent(new ui::KeyEvent(
+      ui::ET_KEY_RELEASED, ui::VKEY_SHIFT, ui::EF_NONE, false));
+}
+
 scoped_ptr<ui::Event> TouchExplorationController::CreateMouseMoveEvent(
     const gfx::PointF& location,
     int flags) {
   return scoped_ptr<ui::Event>(
       new ui::MouseEvent(
           ui::ET_MOUSE_MOVED,
           location,
           location,
           flags | ui::EF_IS_SYNTHESIZED | ui::EF_TOUCH_ACCESSIBILITY,
           0));
 }
 
 void TouchExplorationController::EnterTouchToMouseMode() {
   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() {
+  // Process the gestures.
+  scoped_ptr<ScopedVector<ui::GestureEvent> > gestures;

[aboxhall, 2014/07/02 16:45:57]

You can initialise gestures with GetAndResetPendingGestures here instead of
using reset() on the next line.

[lisayin, 2014/07/02 17:19:43]

Done.

+  gestures.reset(gesture_provider_.GetAndResetPendingGestures());
+   if (gestures != NULL) {

[aboxhall, 2014/07/02 16:45:57]

if (gestures) 
should work I think...

[lisayin, 2014/07/02 17:19:44]

Done.

+    for (ScopedVector<GestureEvent>::iterator i = gestures->begin();
+         i != gestures->end();
+         ++i) {
+      OnGestureEvent(*i);
+    }
+  }
   state_ = NO_FINGERS_DOWN;
   VLOG_STATE();
   if (tap_timer_.IsRunning())
     tap_timer_.Stop();
 }
 
 void TouchExplorationController::VlogState(const char* function_name) {
   if (prev_state_ == state_)
     return;
   prev_state_ = state_;
@@ skipping 36 matching lines @@
     case SINGLE_TAP_PRESSED:
       return "SINGLE_TAP_PRESSED";
     case SINGLE_TAP_RELEASED:
       return "SINGLE_TAP_RELEASED";
     case TOUCH_EXPLORE_RELEASED:
       return "TOUCH_EXPLORE_RELEASED";
     case DOUBLE_TAP_PRESSED:
       return "DOUBLE_TAP_PRESSED";
     case TOUCH_EXPLORATION:
       return "TOUCH_EXPLORATION";
+    case GESTURE_IN_PROGRESS:
+      return "GESTURE_IN_PROGRESS";
     case TOUCH_EXPLORE_SECOND_PRESS:
       return "TOUCH_EXPLORE_SECOND_PRESS";
     case TWO_TO_ONE_FINGER:
       return "TWO_TO_ONE_FINGER";
     case PASSTHROUGH:
       return "PASSTHROUGH";
     case WAIT_FOR_RELEASE:
       return "WAIT_FOR_RELEASE";
   }
   return "Not a state";
 }
 
 }  // namespace ui