Added entry points to view/View to dispatch and process TouchEvents.

views/widget/root_view.cc

 // Copyright (c) 2010 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 "views/widget/root_view.h"
 
 #include <algorithm>
 
 #include "app/drag_drop_types.h"
 #include "app/keyboard_codes.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "gfx/canvas_skia.h"
 #include "views/fill_layout.h"
 #include "views/focus/view_storage.h"
 #include "views/widget/widget.h"
 #include "views/window/window.h"
 
+#if defined(TOUCH_UI)
+#include "views/touchui/gesture_manager.h"
+#endif
+
 #if defined(OS_LINUX)
 #include "views/widget/widget_gtk.h"
 #endif  // defined(OS_LINUX)
 
 namespace views {
 
 /////////////////////////////////////////////////////////////////////////////
 //
 // A Task to trigger non urgent painting.
 //
@@ skipping 40 matching lines @@
       explicit_mouse_handler_(false),
 #if defined(OS_WIN)
       previous_cursor_(NULL),
 #endif
       default_keyboard_handler_(NULL),
       focus_on_mouse_pressed_(false),
       ignore_set_focus_calls_(false),
       focus_traversable_parent_(NULL),
       focus_traversable_parent_view_(NULL),
       drag_view_(NULL)
+#if defined(TOUCH_UI)
+      ,
+      gesture_manager_(GestureManager::Get()),
+      touch_pressed_handler_(NULL)
+#endif
 #ifndef NDEBUG
       ,
       is_processing_paint_(false)
 #endif
 {
 }
 
 RootView::~RootView() {
   // If we have children remove them explicitly so to make sure a remove
   // notification is sent for each one of them.
@@ skipping 193 matching lines @@
       focus_manager->ViewRemoved(parent, child);
 
     ViewStorage::GetSharedInstance()->ViewRemoved(parent, child);
   }
 }
 
 void RootView::SetFocusOnMousePressed(bool f) {
   focus_on_mouse_pressed_ = f;
 }
 
+#if defined(TOUCH_UI)
+bool RootView::OnTouchEvent(const TouchEvent& e) {
+  // If touch_pressed_handler_ is non null, we are currently processing
+  // a touch down on the screen situation. In that case we send the
+  // event to touch_pressed_handler_
+
+  if (touch_pressed_handler_) {
+    TouchEvent touch_event(e, this, touch_pressed_handler_);
+    touch_pressed_handler_->ProcessTouchEvent(touch_event);
+    gesture_manager_->ProcessTouchEventForGesture(e, this, true);
+    return true;
+  }
+
+  bool handled = false;
+  // Walk up the tree until we find a view that wants the touch event.
+  for (touch_pressed_handler_ = GetViewForPoint(e.location());
+       touch_pressed_handler_ && (touch_pressed_handler_ != this);
+       touch_pressed_handler_ = touch_pressed_handler_->GetParent()) {
+    if (!touch_pressed_handler_->IsEnabled()) {
+      // Disabled views eat events but are treated as not handled by the
+      // the GestureManager.
+      handled = false;
+      break;
+    }
+
+    // See if this view wants to handle the touch
+    TouchEvent touch_event(e, this, touch_pressed_handler_);
+    handled = touch_pressed_handler_->ProcessTouchEvent(touch_event);
+
+    // The view could have removed itself from the tree when handling
+    // OnTouchEvent(). So handle as per OnMousePressed. NB: we
+    // assume that the RootView itself cannot be so removed.
+    //
+    // NOTE: Don't return true here, because we don't want the frame to
+    // forward future events to us when there's no handler.
+    if (!touch_pressed_handler_)
+      break;
+
+    // If the view handled the event, leave touch_pressed_handler_ set and
+    // return true, which will cause subsequent drag/release events to get
+    // forwarded to that view.
+    if (handled) {
+      gesture_manager_->ProcessTouchEventForGesture(e, this, handled);
+      return true;
+    }
+  }
+
+  // Reset touch_pressed_handler_ to indicate that no processing is occurring.
+  touch_pressed_handler_ = NULL;
+
+  // Give the touch event to the gesture manager.
+  gesture_manager_->ProcessTouchEventForGesture(e, this, handled);
+  return handled;
+}
+#endif
+
 bool RootView::OnMousePressed(const MouseEvent& e) {
   // This function does not normally handle non-client messages except for
   // non-client double-clicks. Actually, all double-clicks are special as the
   // are formed from a single-click followed by a double-click event. When the
   // double-click event lands on a different view than its single-click part,
   // we transform it into a single-click which prevents odd things.
   if ((e.GetFlags() & MouseEvent::EF_IS_NON_CLIENT) &&
       !(e.GetFlags() & MouseEvent::EF_IS_DOUBLE_CLICK)) {
     last_click_handler_ = NULL;
     return false;
@@ skipping 408 matching lines @@
       static_cast<WidgetGtk*>(GetWidget())->window_contents();
   if (!native_view)
     return;
   gdk_window_set_cursor(native_view->window, cursor);
   if (cursor)
     gdk_cursor_destroy(cursor);
 #endif
 }
 
 }  // namespace views