Implementation of the Touch Exploration Mode - Part I (ui)

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 "ui/aura/client/cursor_client.h"
+#include "ui/aura/window.h"
+#include "ui/aura/window_tree_host.h"
+#include "ui/events/event.h"
+
+namespace ui {
+
+TouchExplorationController::TouchExplorationController(
+    aura::Window* root_window)
+        : root_window_(root_window) {
+  CHECK(root_window);
+  root_window->GetHost()->GetEventSource()->AddEventRewriter(this);
+}
+
+TouchExplorationController::~TouchExplorationController() {
+  root_window_->GetHost()->GetEventSource()->RemoveEventRewriter(this);
+}
+
+ui::EventRewriteStatus TouchExplorationController::RewriteEvent(
+    const ui::Event& event,
+    scoped_ptr<ui::Event>* rewritten_event) {
+  if (!event.IsTouchEvent())
+    return ui::EVENT_REWRITE_CONTINUE;
+
+  const ui::TouchEvent& touch_event =
+      static_cast<const ui::TouchEvent&>(event);
+  const ui::EventType type = touch_event.type();
+  const gfx::PointF& location = touch_event.location_f();
+  const int touch_id = touch_event.touch_id();
+  const int flags = touch_event.flags();
+
+  if (type == ui::ET_TOUCH_PRESSED) {
+    touch_ids_.push_back(touch_id);
+    touch_locations_.insert(std::pair<int, gfx::PointF>(touch_id, location));
+    // If this is the first and only finger touching - rewrite the touch as a
+    // mouse move. Otherwise let the it go through as is.
+    if (touch_ids_.size() == 1) {
+      *rewritten_event = CreateMouseMoveEvent(location, flags);
+      EnterTouchToMouseMode();
+      return ui::EVENT_REWRITE_REWRITTEN;
+    }
+    return ui::EVENT_REWRITE_CONTINUE;
+  } else if (type == ui::ET_TOUCH_RELEASED || type == ui::ET_TOUCH_CANCELLED) {
+    std::vector<int>::iterator it =
+        std::find(touch_ids_.begin(), touch_ids_.end(), touch_id);
+    // We may fail to find the finger if the exploration mode was turned on
+    // while the user had some fingers touching the screen. We simply ignore
+    // those fingers for the purposes of event transformation.
+    if (it == touch_ids_.end())
+      return ui::EVENT_REWRITE_CONTINUE;
+    const bool first_finger_released = it == touch_ids_.begin();
+    touch_ids_.erase(it);
+    int num_erased = touch_locations_.erase(touch_id);
+    DCHECK_EQ(num_erased, 1);
+    const int num_fingers_remaining = touch_ids_.size();
+
+    if (num_fingers_remaining == 0) {
+      *rewritten_event = CreateMouseMoveEvent(location, flags);
+      return ui::EVENT_REWRITE_REWRITTEN;
+    }
+
+    // If we are left with one finger - enter the mouse move mode.
+    const bool enter_mouse_move_mode = num_fingers_remaining == 1;
+
+    if (!enter_mouse_move_mode && !first_finger_released) {
+      // No special handling needed.
+      return ui::EVENT_REWRITE_CONTINUE;
+    }
+
+    // If the finger which was released was the first one, - we need to rewrite
+    // the release event as a release of the was second / now first finger.
+    // This is the finger which will now be getting "substracted".
+    if (first_finger_released) {
+      int rewritten_release_id = touch_ids_[0];
+      const gfx::PointF& rewritten_release_location =
+          touch_locations_[rewritten_release_id];
+      ui::TouchEvent* rewritten_release_event = new ui::TouchEvent(
+          ui::ET_TOUCH_RELEASED,
+          rewritten_release_location,
+          rewritten_release_id,
+          event.time_stamp());
+      rewritten_release_event->set_flags(touch_event.flags());
+      rewritten_event->reset(rewritten_release_event);
+    } else if (enter_mouse_move_mode) {
+      // Dispatch the release event as is.
+      // TODO(mfomitchev): We can get rid of this clause once we have
+      // EVENT_REWRITE_DISPATCH_ANOTHER working without having to set
+      // rewritten_event.
+      rewritten_event->reset(new ui::TouchEvent(touch_event));
+    }
+
+    if (enter_mouse_move_mode) {
+      // Since we are entering the mouse move mode - also dispatch a mouse move
+      // event at the location of the one remaining finger. (num_fingers == 1)
+      const gfx::PointF& mouse_move_location = touch_locations_[touch_ids_[0]];
+      next_dispatch_event_ =
+          CreateMouseMoveEvent(mouse_move_location, flags).Pass();
+      return ui::EVENT_REWRITE_DISPATCH_ANOTHER;
+    }
+    return ui::EVENT_REWRITE_REWRITTEN;
+  } else if (type == ui::ET_TOUCH_MOVED) {
+    std::vector<int>::iterator it =
+        std::find(touch_ids_.begin(), touch_ids_.end(), touch_id);
+    // We may fail to find the finger if the exploration mode was turned on
+    // while the user had some fingers touching the screen. We simply ignore
+    // those fingers for the purposes of event transformation.
+    if (it == touch_ids_.end())
+      return ui::EVENT_REWRITE_CONTINUE;
+    touch_locations_[*it] = location;
+    if (touch_ids_.size() == 1) {
+      // Touch moves are rewritten as mouse moves when there's only one finger
+      // touching the screen.
+      *rewritten_event = CreateMouseMoveEvent(location, flags).Pass();
+      return ui::EVENT_REWRITE_REWRITTEN;
+    }
+    if (touch_id == touch_ids_.front()) {
+      // Touch moves of the first finger are discarded when there's more than
+      // one finger touching.
+      return ui::EVENT_REWRITE_DISCARD;
+    }
+    return ui::EVENT_REWRITE_CONTINUE;
+  }
+  NOTREACHED();

[oshima, 2014/05/02 19:53:38]

nit: can you add brief message to describe what might have went wrong here using

NOTREACHED() << "xxx"? 

[mfomitchev, 2014/05/02 21:27:58]

Done.

+  return ui::EVENT_REWRITE_CONTINUE;
+}
+
+ui::EventRewriteStatus TouchExplorationController::NextDispatchEvent(
+    const ui::Event& last_event,
+    scoped_ptr<ui::Event>* new_event) {
+  CHECK(next_dispatch_event_);
+  DCHECK(last_event.IsTouchEvent());
+  *new_event = next_dispatch_event_.Pass();
+  // Enter the mouse move mode if needed
+  if ((*new_event)->IsMouseEvent())
+    EnterTouchToMouseMode();
+  return ui::EVENT_REWRITE_REWRITTEN;
+}
+
+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_FROM_TOUCH,
+                         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();
+}
+
+}  // namespace ui